class JobOffer(djmodels.Model):
employer = djmodels.ForeignKey(
Player,
related_name='offer_made',
)
worker = djmodels.ForeignKey(Player,
null=True,
related_name='offer_accepted')
group = djmodels.ForeignKey(Group, related_name='offers')
amount = models.IntegerField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
@classmethod
def post_save(cls, sender, instance, created, *args, **kwargs):
employer, worker = instance.employer, instance.worker
group = instance.group
contract_parties = [employer, worker]
if instance.worker:
for p in contract_parties:
p.matched = True
p.save()
p_group = ChannelGroup(p.get_personal_channel_name())
p_group.send({'text': json.dumps({
'day_over': True,
})})
group_channel = ChannelGroup(group.get_channel_group_name())
group_message = {}
if not group.is_active():
group_message['day_over'] = True
group_message['open_offers'] = group.get_active_offers_html()
group_message['general_info'] = group.get_general_info_html()
group_channel.send({'text': json.dumps(group_message)})
class BaseRecord(djmodels.Model):
quantity = models.IntegerField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
player = djmodels.ForeignKey(to=Player,
related_name="%(class)ss", )
class Meta:
abstract = True
class Slot(djmodels.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
owner = djmodels.ForeignKey(
to=Player,
related_name="slots",
)
cost = models.FloatField(doc='this is defined for sellers only', null=True)
value = models.FloatField(doc='for buyers only', null=True)
class Slot(djmodels.Model):
"""A slot is a space with an associated cost or value (depending on a type of a player (buyer or seller). """
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
owner = djmodels.ForeignKey(
to=Player,
related_name="slots",
)
cost = models.FloatField(doc='this is defined for sellers only', null=True)
value = models.FloatField(doc='for buyers only', null=True)
class PayPalPayout(djmodels.Model):
class Meta:
default_related_name = 'payouts'
linked_session = djmodels.ForeignKey(to=LinkedSession, on_delete=djmodels.CASCADE, )
participant = djmodels.ForeignKey(to=Participant, on_delete=djmodels.CASCADE, )
# we set on_delete to NULL because we need to delete failed batches without touching ppp object connected.
batch = djmodels.ForeignKey(to=Batch, on_delete=djmodels.SET_NULL, blank=True, null=True)
email = djmodels.EmailField(blank=True, )
amount = models.FloatField(blank=True, null=True)
payout_item_id = models.StringField(blank=True, doc='returned id from paypal.get()')
inner_status = models.IntegerField(choices=PPP_STATUSES.choices, blank=True, null=True,
initial=PPP_STATUSES.UNPAID)
transaction_status = models.StringField(blank=True, initial='NOT PAID', doc='to get from paypal.get()')
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
to_pay = models.BooleanField(doc='Marked as to pay, but not yet processed, inner status = PROCESSING',
initial=False)
paid = models.BooleanField(doc='paid, inner status PAID',
initial=False)
sender_item_id = models.StringField(blank=True, doc='sent id to paypal', )
info = models.LongStringField(doc='to store info received from paypal.get_payout()')
def get_absolute_url(self):
return self.participant._url_i_should_be_on()
def get_payout_item(self):
self.sender_item_id = generate_random_string(15)
if self.email is None:
return
if self.amount is None:
return
return {
"recipient_type": "EMAIL",
"amount": {
"value": self.amount,
"currency": "USD"
},
"receiver": self.email,
"note": "Thank you.",
"sender_item_id": self.sender_item_id
}
def update_status(self):
if self.payout_item_id == '':
return False
if self.transaction_status not in PPP_IGNORED_STATUSES:
updated_info = paypal.get_payout_item(self.payout_item_id)
if 'error_status' not in updated_info:
self.info = str(updated_info)
self.transaction_status = updated_info['transaction_status']
self.save()
return True
else:
return False
class HFTPlayerStateRecord(Model):
timestamp = models.DateTimeField(auto_now_add=True)
subsession_id = models.StringField()
player_id = models.IntegerField()
market_id = models.StringField()
role = models.StringField()
speed_on = models.BooleanField()
trigger_event_type = models.StringField()
event_no = models.IntegerField()
inventory = models.IntegerField()
orderstore = models.StringField()
bid = models.IntegerField(blank=True)
offer = models.IntegerField(blank=True)
def from_event_and_player(self, event, player):
for field in ('role', 'market_id', 'speed_on', 'inventory', 'bid',
'offer', 'orderstore'):
setattr(self, field, getattr(player, field))
self.trigger_event_type = str(event.event_type)
self.event_no = int(event.reference_no)
self.session_id = int(player.session.id)
self.subsession_id = str(player.subsession.id)
self.player_id = int(player.id)
return self
class HFTInvestorRecord(Model):
timestamp = models.DateTimeField(auto_now_add=True)
exchange_timestamp = models.BigIntegerField()
subsession_id= models.StringField()
market_id = models.StringField()
order_token = models.StringField()
status = models.StringField()
buy_sell_indicator = models.StringField()
price = models.IntegerField()
def from_event(self, event):
self.subsession_id = str(event.attachments['subsession_id'])
self.market_id = str(event.attachments['market_id'])
self.status = event.event_type
self.order_token = event.message['order_token']
if 'buy_sell_indicator' in event.message:
self.buy_sell_indicator = event.message['buy_sell_indicator']
else:
self.buy_sell_indicator = event.message['order_token'][4]
if 'price' in event.message:
self.price = event.message['price']
else:
self.price = event.message['execution_price']
self.exchange_timestamp = event.message['timestamp']
return self
class Group(BaseGroup):
timerDict_DecisionPage = {
"starting_time": 0,
"session_id": 0,
"round_number": 0,
"subsession_id": 0
}
updateTimer_DecisionPage = UpdateData(Constants.c_refresh_to_clients_insec,
sendUpdatedData,
kwargs=timerDict_DecisionPage)
timer_DecisionPage_started = models.BooleanField(initial=False)
timer_DecisionPage_startingTime = models.DateTimeField()
def startTimer_DecisionPage(self):
# Start the timer
if self.timer_DecisionPage_started == False:
self.timerDict_DecisionPage["starting_time"] = datetime.now()
self.timerDict_DecisionPage["session_id"] = self.session.id
self.timerDict_DecisionPage[
"round_number"] = self.subsession.round_number
self.timerDict_DecisionPage["subsession_id"] = self.subsession.id
self.updateTimer_DecisionPage.start()
self.timer_DecisionPage_startingTime = timezone.make_aware(
datetime.now(), timezone.get_default_timezone())
self.timer_DecisionPage_started = True
def stopTimer_DecisionPage(self):
self.updateTimer_DecisionPage.stop() # Called from the next "waitpage"
class Group(BaseGroup):
timerDict_Q1Pop1 = {
"starting_time": 0,
"session_id": 0,
"round_number": 0,
"subsession_id": 0
}
updateTimer_Q1Pop1 = UpdateData(Constants.refresh_period_insec,
sendUpdatedData,
kwargs=timerDict_Q1Pop1)
timer_Q1Pop1_started = models.BooleanField(initial=False)
timer_Q1Pop1_startingTime = models.DateTimeField()
def startTimer_Q1Pop1(self):
# Start the timer
if self.timer_Q1Pop1_started == False:
self.timerDict_Q1Pop1["starting_time"] = datetime.now()
self.timerDict_Q1Pop1["session_id"] = self.session.id
self.timerDict_Q1Pop1[
"round_number"] = self.subsession.round_number
self.timerDict_Q1Pop1["subsession_id"] = self.subsession.id
self.updateTimer_Q1Pop1.start()
self.timer_Q1Pop1_startingTime = timezone.make_aware(
datetime.now(), timezone.get_default_timezone())
self.timer_Q1Pop1_started = True
def stopTimer_Q1Pop1(self):
self.updateTimer_Q1Pop1.stop(
) #??? Wait that the last player has left before stopping
class Task2(djmodels.Model):
class Meta:
"""We also do not crucially need this but it is convenient to pick just the most recent unanswered task.
Ideally there should be just one, but just in case it is better to be safe."""
get_latest_by = 'created_at'
player = djmodels.ForeignKey(to=Player, related_name='tasks2')
question = djmodels.ForeignKey(to=Q2, related_name='answers')
answer = models.StringField()
created_at = models.DateTimeField(auto_now_add=True) # this and the following field is to track time
updated_at = models.DateTimeField(auto_now=True)
test = models.BooleanField()
def get_answer_time(self):
"""We need this to show the question durations for the user in a nice mode."""
sec = (self.updated_at - self.created_at).total_seconds()
return f'{int((sec / 60) % 60):02d}:{int(sec):02d}'
class JobContract(djmodels.Model):
employer = djmodels.ForeignKey(Player,
related_name='contract',
unique=True)
worker = djmodels.ForeignKey(Player,
blank=True,
null=True,
related_name='work_to_do')
amount = models.IntegerField()
accepted = models.BooleanField()
amount_updated = models.IntegerField(blank=True)
tasks_corr = models.PositiveIntegerField(initial=0)
tasks_att = models.PositiveIntegerField(initial=0)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
auctionenddate = models.FloatField()
day_over = models.BooleanField()
class ExogenousEventFile(Model):
upload_time = models.DateTimeField(auto_now_add=True)
upload_name = models.StringField()
code = models.CharField(primary_key=True,
default=random_chars_8,
editable=False,
null=False)
record_type = models.StringField()
class Connection(djmodels.Model):
class Meta:
ordering = ['-created_at']
EVENT_TYPES = [('connected', 'CONNECTED'), ('disconnected', 'DISCONNECTED'), ('success_post', 'SUCCESS_POST')]
created_at = models.DateTimeField(auto_now_add=True)
participant = djmodels.ForeignKey(to=Participant)
event_type = models.CharField(choices=EVENT_TYPES)
def __str__(self):
return 'Connection: {} for the participant {}'.format(self.event_type, self.participant.code)
class Subsession(BaseSubsession):
num_sellers = models.IntegerField()
num_buyers = models.IntegerField()
start_time = models.DateTimeField()
def creating_session(self):
self.num_buyers = self.session.config.get('buyers')
self.num_sellers = self.session.config.get('sellers')
self.start_time = timezone.now()
if self.session.num_participants % (self.num_buyers + self.num_sellers) != 0:
raise Exception('Number of participants is not divisible by number of sellers and buyers')
class TransitiveDecision(
Model): # our custom model inherits from Django's base class "Model"
player_decision = models.IntegerField(choices=Choices.choices_q123,
initial=Choices.choices_q123[0])
related_question = models.CharField(choices=Choices.questions,
initial=Choices.questions[0])
timestamp = models.DateTimeField()
player = ForeignKey(
Player
) # creates 1:m relation -> this decision was made by a certain player
argument = ManyToManyField(Argument) # creates m:m relation
def save(self, *args, **kwargs):
''' On save, update timestamps '''
self.timestamp = timezone.make_aware(datetime.now(),
timezone.get_default_timezone())
return super(TransitiveDecision, self).save(*args, **kwargs)
class TransitiveDecision(
Model): # our custom model inherits from Django's base class "Model"
player = ForeignKey(
Player
) # creates 1:m relation -> this decision was made by a certain player
argument = ManyToManyField(Argument,
limit_choices_to={
'arg_status':
Constants.c_arguments_status[1]
}) # creates m:m relation
timestamp = models.DateTimeField()
round_number = models.PositiveIntegerField()
nb_ETP = models.FloatField(min=0, max=Constants.c_max_nb_ETP, initial=0)
def save(self, *args, **kwargs):
self.timestamp = timezone.make_aware(datetime.now(),
timezone.get_default_timezone())
return super(TransitiveDecision, self).save(*args, **kwargs)
class PrivateMessage(models.Model):
wall = models.ForeignKey(PrivateMessageBoard)
createdBy = models.ForeignKey(Node)
datetime = models.DateTimeField(auto_now=True)
message = models.CharField()
messageRound = models.IntegerField()
deleted = models.BooleanField(initial=False)
key = models.CharField()
def to_dict(self):
return {
'id': self.id,
'timestamp': self.datetime.strftime("%Y-%m-%d %H:%M:%S"),
'content': self.message,
'author': 'Player {}'.format(self.createdBy_id),
'messageRound': self.messageRound,
'key': self.key,
}
class HFTEventRecord(Model):
subsession_id= models.StringField()
market_id = models.StringField()
timestamp = models.DateTimeField(auto_now_add=True)
event_no = models.IntegerField()
event_source = models.StringField()
event_type = models.StringField()
original_message = models.StringField()
attachments = models.StringField()
outgoing_messages = models.StringField()
def from_event(self, event):
self.subsession_id = str(event.attachments['subsession_id'])
self.market_id = str(event.attachments['market_id'])
self.event_no = int(event.reference_no)
self.event_type = str(event.event_type)
self.event_source = str(event.event_source)
self.original_message = str(event.message)
self.attachments = str(event.attachments)
self.outgoing_messages = str(event.outgoing_messages)
return self
class Player(BasePlayer):
page_sequence = models.StringField()
# mobile or desktop PC
mobile_user = models.StringField()
#timers
starttime = models.DateTimeField()
endtime = models.DateTimeField()
immi_first = models.StringField()
man_woman_first_pic = models.StringField()
man_woman_second_pic = models.StringField()
headscarf_first_pic = models.StringField()
immi_left_right = models.StringField()
headscarf_split = models.StringField()
first_pic = models.StringField()
second_pic = models.StringField()
third_pic = models.StringField()
fourth_pic = models.StringField()
first_name = models.StringField()
second_name = models.StringField()
third_name = models.StringField()
fourth_name = models.StringField()
first_age = models.StringField()
second_age = models.StringField()
third_age = models.StringField()
fourth_age = models.StringField()
first_bl = models.StringField()
second_bl = models.StringField()
third_bl = models.StringField()
fourth_bl = models.StringField()
newsprime = models.StringField()
afd_first = models.BooleanField()
def set_prime(self):
self.newsprime = random.choice(['yes', 'no'])
self.afd_first = False
def set_picture_order(self):
gM1 = 'pictures/MD1_Stefan.png'
gM2 = 'pictures/MD2_Felix.png'
gW1 = 'pictures/WD1_Leni.png'
gW2 = 'pictures/WD2_Marina.png'
iM1 = 'pictures/MI1_Hooman.png'
iM2 = 'pictures/MI2_Mostafa.png'
iW1 = 'pictures/WI1_Bouba.png'
iW2 = 'pictures/WI2_Esra.png'
iW1hs = 'pictures/WH1_Bouba.png'
iW2hs = 'pictures/WH2_Esra.png'
names_dict = dict([
(gM1, 'Nico'),
(gM2, 'Sven'),
(gW1, 'Conny'),
(gW2, 'Saskia'),
(iM1, 'Ali'),
(iM2, 'Mohammed'),
(iW1, 'Farida'),
(iW2, 'Özlem'),
(iW1hs, 'Farida'),
(iW2hs, 'Özlem'),
])
age_dict = dict([
(gM1, '29'),
(gM2, '31'),
(gW1, '33'),
(gW2, '34'),
(iM1, '35'),
(iM2, '32'),
(iW1, '34'),
(iW2, '33'),
(iW1hs, '34'),
(iW2hs, '33'),
])
# set random order
self.immi_first = random.choice(['yes', 'no'])
self.man_woman_first_pic = random.choice(['man', 'woman'])
self.man_woman_second_pic = random.choice(['man', 'woman'])
self.headscarf_first_pic = random.choice(['yes', 'no'])
# select first and second pic
if self.immi_first == 'no':
if self.man_woman_first_pic == 'man':
self.first_pic = random.choice([gM1, gM2])
elif self.man_woman_first_pic == 'woman':
self.first_pic = random.choice([gW1, gW2])
# second picture
if self.man_woman_second_pic == 'man':
self.second_pic = random.choice([iM1, iM2])
else:
if self.headscarf_first_pic == 'no':
self.second_pic = random.choice([iW1, iW2])
elif self.headscarf_first_pic == 'yes':
self.second_pic = random.choice([iW1hs, iW2hs])
elif self.immi_first == 'yes':
# first picture
if self.man_woman_first_pic == 'man':
self.first_pic = random.choice([iM1, iM2])
else:
if self.headscarf_first_pic == 'no':
self.first_pic = random.choice([iW1, iW2])
elif self.headscarf_first_pic == 'yes':
self.first_pic = random.choice([iW1hs, iW2hs])
# second picture
if self.man_woman_second_pic == 'man':
self.second_pic = random.choice([gM1, gM2])
if self.man_woman_second_pic == 'woman':
self.second_pic = random.choice([gW1, gW2])
# third and fourth pictures
self.immi_left_right = random.choice(['left', 'right'])
self.headscarf_split = random.choice(['yes', 'no'])
choicelist = [self.first_pic, self.second_pic]
glist = [gM1, gM2, gW1, gW2]
glistleft = [x for x in glist if x not in choicelist]
gmlist = [gM1, gM2]
gwlist = [gW1, gW2]
imlist = [iM1, iM2]
imlistleft = [x for x in imlist if x not in choicelist]
iwlist = [iW1, iW2]
iwlistleft = [x for x in iwlist if x not in choicelist]
iwhslist = [iW1hs, iW2hs]
iwhslistleft = [x for x in iwhslist if x not in choicelist]
if self.immi_left_right == 'right':
# Third picture choice of leftover native profiles
self.third_pic = random.choice(glistleft)
# if a native man is chosen, choose immigrant man
if self.third_pic in gmlist:
self.fourth_pic = random.choice(imlistleft)
# if a native woman is chosen, choose immigrant woman, either with our without headscarf
elif self.third_pic in gwlist:
if self.headscarf_split == 'no':
self.fourth_pic = random.choice(iwlistleft)
elif self.headscarf_split == 'yes':
self.fourth_pic = random.choice(iwhslistleft)
elif self.immi_left_right == 'left':
self.fourth_pic = random.choice(glistleft)
if self.fourth_pic in gmlist:
self.third_pic = random.choice(imlistleft)
elif self.fourth_pic in gwlist:
if self.headscarf_split == 'no':
self.third_pic = random.choice(iwlistleft)
elif self.headscarf_split == 'yes':
self.third_pic = random.choice(iwhslistleft)
# set names
self.first_name = names_dict[self.first_pic]
self.second_name = names_dict[self.second_pic]
self.third_name = names_dict[self.third_pic]
self.fourth_name = names_dict[self.fourth_pic]
# set ages
self.first_age = age_dict[self.first_pic]
self.second_age = age_dict[self.second_pic]
self.third_age = age_dict[self.third_pic]
self.fourth_age = age_dict[self.fourth_pic]
# set BL
self.first_bl = random.choice([
'Brandenburg', 'Mecklenburg-Vorpommern', 'Sachsen',
'Sachsen-Anhalt', 'Thüringen'
])
self.second_bl = random.choice([
'Brandenburg', 'Mecklenburg-Vorpommern', 'Sachsen',
'Sachsen-Anhalt', 'Thüringen'
])
self.third_bl = random.choice([
'Brandenburg', 'Mecklenburg-Vorpommern', 'Sachsen',
'Sachsen-Anhalt', 'Thüringen'
])
self.fourth_bl = random.choice([
'Brandenburg', 'Mecklenburg-Vorpommern', 'Sachsen',
'Sachsen-Anhalt', 'Thüringen'
])
dec_dg1 = models.PositiveIntegerField(
choices=[
[0, '0,00€'],
[1, '0,50€'],
[2, '1,00€'],
[3, '1,50€'],
[4, '2,00€'],
[5, '2,50€'],
[6, '3,00€'],
[7, '3,50€'],
[8, '4,00€'],
[9, '4,50€'],
[10, '5,00€'],
],
widget=widgets.RadioSelectHorizontal(),
)
dec_dg2 = models.PositiveIntegerField(
choices=[
[0, '0,00€'],
[1, '0,50€'],
[2, '1,00€'],
[3, '1,50€'],
[4, '2,00€'],
[5, '2,50€'],
[6, '3,00€'],
[7, '3,50€'],
[8, '4,00€'],
[9, '4,50€'],
[10, '5,00€'],
],
widget=widgets.RadioSelectHorizontal(),
)
dec_tg1 = models.PositiveIntegerField(
choices=[
[0, '0,00€'],
[1, '0,50€'],
[2, '1,00€'],
[3, '1,50€'],
[4, '2,00€'],
[5, '2,50€'],
[6, '3,00€'],
[7, '3,50€'],
[8, '4,00€'],
[9, '4,50€'],
[10, '5,00€'],
],
widget=widgets.RadioSelect(),
)
dec_tg2 = models.PositiveIntegerField(
choices=[
[0, '0,00€'],
[1, '0,50€'],
[2, '1,00€'],
[3, '1,50€'],
[4, '2,00€'],
[5, '2,50€'],
[6, '3,00€'],
[7, '3,50€'],
[8, '4,00€'],
[9, '4,50€'],
[10, '5,00€'],
],
widget=widgets.RadioSelect(),
)
dec_split = models.PositiveIntegerField(min=0, max=10)
po_dg1 = models.DecimalField(max_digits=5, decimal_places=2)
po_dg1_shown = models.StringField()
po_dg2 = models.DecimalField(max_digits=5, decimal_places=2)
po_dg2_shown = models.StringField()
po_tg1 = models.DecimalField(max_digits=5, decimal_places=2)
po_tg1_shown = models.StringField()
tg1_multifac = models.DecimalField(max_digits=5, decimal_places=2)
po_tg2 = models.DecimalField(max_digits=5, decimal_places=2)
po_tg2_shown = models.StringField()
tg2_multifac = models.DecimalField(max_digits=5, decimal_places=2)
dec_dg1_shown = models.StringField()
dec_dg2_shown = models.StringField()
dec_tg1_shown = models.StringField()
dec_tg2_shown = models.StringField()
tg1_sentback_shown = models.StringField()
tg2_sentback_shown = models.StringField()
final_payoff = models.DecimalField(max_digits=5, decimal_places=2)
final_payoff_shown = models.StringField()
dec_excluded = models.PositiveIntegerField(choices=[
[1, 'Entscheidungssituation 1'],
[2, 'Entscheidungssituation 2'],
[3, 'Entscheidungssituation 3'],
[4, 'Entscheidungssituation 4'],
], )
def calculate_payoffs(self):
self.po_dg1 = 5 - float(self.dec_dg1) / 2
self.po_dg1_shown = "{:.2f}".format(self.po_dg1).replace('.', ',')
self.po_dg2 = 5 - float(self.dec_dg2) / 2
self.po_dg2_shown = "{:.2f}".format(self.po_dg2).replace('.', ',')
# TG payoff calculation. Expression below chooses multiplication factor according to distribution in SOEP trust game (Fehr 2002)
self.tg1_multifac = np.random.choice(
[0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1],
p=[
0.159, 0.027, 0.053, 0.049, 0.054, 0.352, 0.059, 0.031, 0.029,
0.029, 0.158
])
# payoff = amount left (recorded numbers are twice indicated amount) + double amount times multiplication factor
po_tg1_prelim = (5 - float(self.dec_tg1) / 2) + float(
self.dec_tg1) * float(self.tg1_multifac)
# round to .5
self.po_tg1 = .5 * round(float(po_tg1_prelim) / .5)
self.po_tg1_shown = "{:.2f}".format(self.po_tg1).replace('.', ',')
tg1_sentback = self.po_tg1 - (5 - float(self.dec_tg1) / 2)
self.tg1_sentback_shown = "{:.2f}".format(tg1_sentback).replace(
'.', ',')
self.tg2_multifac = np.random.choice(
[0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1],
p=[
0.159, 0.027, 0.053, 0.049, 0.054, 0.352, 0.059, 0.031, 0.029,
0.029, 0.158
])
po_tg2_prelim = (5 - float(self.dec_tg2) / 2) + float(
self.dec_tg2) * float(self.tg2_multifac)
self.po_tg2 = .5 * round(float(po_tg2_prelim) / .5)
self.po_tg2_shown = "{:.2f}".format(self.po_tg2).replace('.', ',')
tg2_sentback = self.po_tg2 - (5 - float(self.dec_tg2) / 2)
self.tg2_sentback_shown = "{:.2f}".format(tg2_sentback).replace(
'.', ',')
# displayed game decisions
dec_dg1_prelim = float(self.dec_dg1) / 2
self.dec_dg1_shown = "{:.2f}".format(dec_dg1_prelim).replace('.', ',')
dec_dg2_prelim = float(self.dec_dg2) / 2
self.dec_dg2_shown = "{:.2f}".format(dec_dg2_prelim).replace('.', ',')
dec_tg1_prelim = float(self.dec_tg1) / 2
self.dec_tg1_shown = "{:.2f}".format(dec_tg1_prelim).replace('.', ',')
dec_tg2_prelim = float(self.dec_tg2) / 2
self.dec_tg2_shown = "{:.2f}".format(dec_tg2_prelim).replace('.', ',')
# calculate final payoff, excluding one decision
if self.dec_excluded == 1:
final_payoff_prelim = float(self.po_tg1) + float(
self.po_tg2) + float(self.po_dg2)
elif self.dec_excluded == 2:
final_payoff_prelim = float(self.po_dg1) + float(
self.po_tg2) + float(self.po_dg2)
elif self.dec_excluded == 3:
final_payoff_prelim = float(self.po_dg1) + float(
self.po_tg1) + float(self.po_dg2)
elif self.dec_excluded == 4:
final_payoff_prelim = float(self.po_dg1) + float(
self.po_tg1) + float(self.po_tg2)
if final_payoff_prelim < 10:
self.final_payoff = 10
elif final_payoff_prelim > 20:
self.final_payoff = 20
else:
self.final_payoff = final_payoff_prelim
self.final_payoff_shown = "{:.2f}".format(self.final_payoff).replace(
'.', ',')
# demographics
gender = models.StringField(choices=['Weiblich', 'Männlich'])
age = models.PositiveIntegerField(min=18, max=99)
married = models.PositiveIntegerField(choices=[
[1, 'Verheiratet und leben mit Ehepartner zusammen'],
[2, 'Nicht verheiratet aber in fester Lebensgemeinschaft'],
[3, 'Verheiratet und leben getrennt'],
[4, 'Verwitwet'],
[5, 'Geschieden'],
[6, 'Ledig'],
], )
children = models.PositiveIntegerField(choices=[
[1, 'Nein'],
[2, 'Ja, 1 Kind'],
[3, 'Ja, 2 Kinder'],
[4, 'Ja, 3 Kinder oder mehr'],
], )
household = models.PositiveIntegerField(choices=[
[1, 'Nein, lebe allein'],
[2, 'Ja, noch 1 andere Person'],
[3, 'Ja, noch 2 andere Personen'],
[4, 'Ja, noch 3 andere Personen'],
[5, 'Ja, mehr als 3 andere Personen'],
], )
bundesland = models.PositiveIntegerField(choices=[
[1, 'Baden-Württemberg'],
[2, 'Bayern'],
[3, 'Berlin'],
[4, 'Bremen'],
[5, 'Brandenburg'],
[6, 'Hamburg'],
[7, 'Hessen'],
[8, 'Mecklenburg-Vorpommern'],
[9, 'Niedersachsen'],
[10, 'Nordrhein-Westfalen'],
[11, 'Rheinland-Pfalz'],
[12, 'Saarland'],
[13, 'Sachsen'],
[14, 'Sachsen-Anhalt'],
[15, 'Schleswig-Holstein'],
[16, 'Thüringen'],
], )
village = models.StringField()
residencetime = models.PositiveIntegerField(choices=[
[1, 'weniger als 1 Jahr'],
[2, '1-3 Jahren'],
[3, '4-10 Jahren'],
[4, 'seit mehr 10 oder mehr Jahren'],
], )
neighborsmovingout = models.PositiveIntegerField(
choices=[[1, 'Keine Nachbarn sind weggezogen'],
[2, '1-3 Nachbarn sind weggezogen'],
[3, '4-10 Nachbarn sind weggezogen'],
[4, '11 oder mehr Nachbarn sind weggezogen'],
[999, 'weiß nicht/ keine Angabe']], )
neighborsmovingin = models.PositiveIntegerField(
choices=[[1, 'Keine Nachbarn sind hergezogen'],
[2, '1-3 Nachbarn sind hergezogen'],
[3, '4-10 Nachbarn sind hergezogen'],
[4, '11 oder mehr Nachbarn sind hergezogen'],
[999, 'weiß nicht/ keine Angabe']], )
election = models.PositiveIntegerField(choices=[
[1, 'ja, habe gewählt '],
[2, 'nein, habe nicht gewählt'],
], )
party = models.PositiveIntegerField(choices=[
[1, 'CDU'],
[2, 'SPD'],
[3, 'DIE LINKE'],
[4, 'AfD'],
[5, 'FDP'],
[6, 'DIE GRÜNEN'],
[7, 'NPD '],
[8, 'andere Partei'],
], )
partyif = models.PositiveIntegerField(choices=[
[1, 'CDU'],
[2, 'SPD'],
[3, 'DIE LINKE'],
[4, 'AfD'],
[5, 'FDP'],
[6, 'DIE GRÜNEN'],
[7, 'NPD '],
[8, 'andere Partei'],
], )
afd = models.PositiveIntegerField(choices=[
[1, '-5, halte überhaupt nichts von dieser Partei'],
[2, '-4'],
[3, '-3'],
[4, '-2'],
[5, '-1'],
[6, '0'],
[7, '+1'],
[8, '+2'],
[9, '+3'],
[10, '+4'],
[11, '+5, halte sehr viel von dieser Partei'],
[999, 'weiß nicht/ keine Angabe'],
], )
manipulationcheck = models.PositiveIntegerField(choices=[
[1, '1, entsprechen gar nicht meiner persönlichen Wahrnehmung'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7, entsprechen voll meiner persönlichen Wahrnehmung'],
[999, 'weiß nicht/ keine Angabe'],
], )
petition = models.PositiveIntegerField(choices=[
[1, '1, lehne die Petition völlig ab'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7'],
[8, '8'],
[9, '9'],
[10, '10'],
[11, '11, unterstütze die Petition voll und ganz'],
[999, 'weiß nicht/ keine Angabe'],
], )
populism1 = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
populism2 = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
nationalism1 = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
nationalism2 = models.PositiveIntegerField(choices=[
[1, 'Sehr zufrieden'],
[2, 'Zufrieden'],
[3, 'Teils zufrieden/teils unzufrieden'],
[4, 'Unzufrieden'],
[5, 'Sehr unzufrieden'],
[999, 'weiß nicht/ keine Angabe'],
], )
nationalism3 = models.PositiveIntegerField(choices=[
[1, 'überhaupt nicht stolz'],
[2, 'nicht sehr stolz'],
[3, 'ziemlich stolz'],
[4, 'sehr stolz'],
[999, 'weiß nicht/ keine Angabe'],
], )
rightwing1 = models.PositiveIntegerField(choices=[
[1, '1, stimme überhaupt nicht zu'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7, stimme voll und ganz zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
rightwing2 = models.PositiveIntegerField(choices=[
[1, '1, stimme überhaupt nicht zu'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7, stimme voll und ganz zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
authoritarian1 = models.PositiveIntegerField(choices=[
[1, 'Unabhängigkeit'],
[2, 'Achtung vor älteren Menschen '],
[999, 'weiß nicht/ keine Angabe'],
], )
authoritarian2 = models.PositiveIntegerField(choices=[
[1, 'Neugier'],
[2, 'Gutes Benehmen'],
[999, 'weiß nicht/ keine Angabe'],
], )
authoritarian3 = models.PositiveIntegerField(choices=[
[1, 'Gehorsam'],
[2, 'Eigenständigkeit'],
[999, 'weiß nicht/ keine Angabe'],
], )
authoritarian4 = models.PositiveIntegerField(choices=[
[1, 'Rücksichtsvoll'],
[2, 'Wohlerzogen'],
[999, 'weiß nicht/ keine Angabe'],
], )
immposi1 = models.PositiveIntegerField(choices=[
[1, '1, stimme überhaupt nicht zu'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7, stimme voll und ganz zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
immposi2 = models.PositiveIntegerField(choices=[
[1, '1, stimme überhaupt nicht zu'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7, stimme voll und ganz zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
attdiff1 = models.PositiveIntegerField(choices=[
[1, 'Der Zuzug soll uneingeschränkt möglich sein'],
[2, 'Der Zuzug soll begrenzt werden'],
[3, 'Der Zuzug soll völlig unterbunden werden'],
[999, 'weiß nicht/ keine Angabe'],
], )
attdiff2 = models.PositiveIntegerField(choices=[
[1, 'Der Zuzug soll uneingeschränkt möglich sein'],
[2, 'Der Zuzug soll begrenzt werden'],
[3, 'Der Zuzug soll völlig unterbunden werden'],
[999, 'weiß nicht/ keine Angabe'],
], )
attdiff3 = models.PositiveIntegerField(choices=[
[1, 'Der Zuzug soll uneingeschränkt möglich sein'],
[2, 'Der Zuzug soll begrenzt werden'],
[3, 'Der Zuzug soll völlig unterbunden werden'],
[999, 'weiß nicht/ keine Angabe'],
], )
attdiff4 = models.PositiveIntegerField(choices=[
[1, 'Der Zuzug soll uneingeschränkt möglich sein'],
[2, 'Der Zuzug soll begrenzt werden'],
[3, 'Der Zuzug soll völlig unterbunden werden'],
[999, 'weiß nicht/ keine Angabe'],
], )
asyl_compete = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Stimme eher nicht zu'],
[4, 'Stimme überhaupt nicht zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
asyl_deport = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
asyl_diverse = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
asyl_protect = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
percentageforeignbula = models.StringField(blank=True)
percentageforeignvillage = models.PositiveIntegerField(choices=[
[1, 'Nein, es gibt keine.'],
[2, 'ca. 1-10 Einzelpersonen'],
[3, 'ca. 11-50 Einzelpersonen'],
[4, 'ca. 51-100 Einzelpersonen'],
[5, '101-199 Einzelpersonen'],
[6, 'Mehr als 200 Einzelpersonen'],
[6, 'Mehr als 1000 Einzelpersonen'],
], )
aquaintances = models.PositiveIntegerField(choices=[
[1, 'niemand'],
[2, '1-3'],
[3, '4-5'],
[4, 'mehr als 5'],
], )
aquaintancesrefugees = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[3, 'Teilweise'],
[999, 'weiß nicht/ keine Angabe'],
], )
refugees = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
contactrefugees = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
contactrefugeesplace = MultiSelectField(
choices=Constants.contactplaces,
blank=True,
)
supportrefugees1 = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
supportrefugees2 = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
againstrefugees = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
understandcontraref = models.PositiveIntegerField(choices=[
[1, 'Ja, habe volles Verständnis'],
[2, 'Ja, habe etwas Verständnis'],
[3, 'Nein, habe kein Verständnis'],
[4, 'Nein, überhaupt kein Verständnis'],
[999, 'weiß nicht/ keine Angabe'],
], )
understandproref = models.PositiveIntegerField(choices=[
[1, 'Ja, habe volles Verständnis'],
[2, 'Ja, habe etwas Verständnis'],
[3, 'Nein, habe kein Verständnis'],
[4, 'Nein, überhaupt kein Verständnis'],
[999, 'weiß nicht/ keine Angabe'],
], )
feelingforeign = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
politicians = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
splitcommunity = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[2, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
sympathy = models.PositiveIntegerField(choices=[
[1, 'Sehr viel'],
[2, 'Eher viel'],
[3, 'Eher wenig'],
[4, 'Wenig '],
[999, 'weiß nicht/ keine Angabe'],
], )
fearalone = models.PositiveIntegerField(choices=[
[1, 'Ja, gibt es hier'],
[0, 'Nein, gibt es hier nicht'],
[999, 'weiß nicht/ keine Angabe'],
], )
feartheft = models.PositiveIntegerField(choices=[
[1, 'Höchst wahrscheinlich'],
[2, 'Eher wahrscheinlich'],
[3, 'Wahrscheinlich'],
[4, 'Eher unwahrscheinlich'],
[5, 'Völlig unwahrscheinlich'],
[999, 'weiß nicht/ keine Angabe'],
], )
fearviolence = models.PositiveIntegerField(choices=[
[1, 'Höchst wahrscheinlich'],
[2, 'Eher wahrscheinlich'],
[3, 'Wahrscheinlich'],
[4, 'Eher unwahrscheinlich'],
[5, 'Völlig unwahrscheinlich'],
[999, 'weiß nicht/ keine Angabe'],
], )
ownfinancial = models.PositiveIntegerField(choices=[
[1, 'Schlecht'],
[2, 'Weniger gut'],
[3, 'Gut'],
[4, 'Sehr gut'],
[999, 'weiß nicht/ keine Angabe'],
], )
fairshare = models.PositiveIntegerField(choices=[
[1, 'Erhalte sehr viel weniger als gerechten Anteil'],
[2, 'Erhalte etwas weniger als gerechten Anteil'],
[3, 'Erhalte gerechten Anteil'],
[4, 'Erhalte etwas mehr als gerechten Anteil'],
[5, 'Erhalte sehr viel mehr als gerechten Anteil'],
[999, 'weiß nicht/ keine Angabe'],
], )
loserside = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
secondclass = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
neighborpoles = models.PositiveIntegerField(choices=[
[1, '+3: wären mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wären mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
neighborturks = models.PositiveIntegerField(choices=[
[1, '+3: wären mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wären mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
neighborsyrian = models.PositiveIntegerField(choices=[
[1, '+3: wären mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wären mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
neighbornigerian = models.PositiveIntegerField(choices=[
[1, '+3: wären mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wären mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
familypoles = models.PositiveIntegerField(choices=[
[1, '+3: wäre mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wäre mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
familyturks = models.PositiveIntegerField(choices=[
[1, '+3: wäre mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wäre mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
familysyrian = models.PositiveIntegerField(choices=[
[1, '+3: wäre mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wäre mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
familynigerian = models.PositiveIntegerField(choices=[
[1, '+3: wäre mir sehr angenehm'],
[2, '+2 '],
[3, '+1: eher angenehm'],
[4, ' 0: ist mir egal'],
[5, '-1: eher unangenehm'],
[6, '-2 '],
[7, '-3: wäre mir sehr unangenehm'],
[999, 'weiß nicht/ keine Angabe'],
], )
muslim1 = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Stimme nicht zu'],
[4, 'Stimme überhaupt nicht zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
muslim2 = models.PositiveIntegerField(choices=[
[1, 'Stimme völlig zu'],
[2, 'Stimme überwiegend zu'],
[3, 'Lehne überwiegend ab'],
[4, 'Lehne völlig ab'],
[999, 'weiß nicht/ keine Angabe'],
], )
education = models.PositiveIntegerField(choices=[
[1, 'Schule beendet ohne Abschluss'],
[2, 'Hauptschulabschluss/ Volksschulabschluss'],
[3, 'Realschulabschluss/ Mittlere Reife'],
[4, 'Fachhochschulreife (Abschluss einer Fachoberschule)'],
[5, 'Abitur bzw. Hochschulreife '],
[6, 'noch in der Schule'],
], )
employed = models.PositiveIntegerField(choices=[
[1, 'Vollzeit erwerbstätig'],
[2, 'Teilzeit erwerbstätig'],
[3, 'in Ausbildung/Studium'],
[4, 'nicht erwerbstätig'],
[5, 'trifft nicht zu'],
[999, 'weiß nicht/ keine Angabe'],
], )
notemployed = models.PositiveIntegerField(choices=[
[1, 'in Rente, Pension oder im Vorruhestand'],
[2, 'Hausfrau/Hausmann'],
[3, 'Mutterschutz/Elternzeit'],
[4, 'arbeitslos (inkl. Ein-Euro-Jobs)'],
[5, 'aus anderen Gründen nicht berufstätig'],
[999, 'weiß nicht/ keine Angabe'],
], )
religion = models.PositiveIntegerField(choices=[
[1, 'römisch-katholische Kirche '],
[2, 'evangelisch/protestantische Kirche'],
[3, 'andere Glaubensgemeinschaft'],
[4, 'keine Glaubensgemeinschaft '],
[999, 'weiß nicht/ keine Angabe'],
], )
selfmigrant = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
selfvertrieben = models.PositiveIntegerField(choices=[
[1, 'Ja'],
[0, 'Nein'],
[999, 'weiß nicht/ keine Angabe'],
], )
politics = models.PositiveIntegerField(choices=[
[1, 'sehr stark'],
[2, 'stark'],
[3, 'mittelmäßig'],
[4, 'weniger stark'],
[5, 'überhaupt nicht'],
[999, 'weiß nicht/ keine Angabe'],
], )
mainsourcenews = models.PositiveIntegerField(choices=[
[1, 'Fernsehen'],
[2, 'Zeitung'],
[3, 'Radio'],
[4, 'Internet'],
[5, 'persönliche Gespräche'],
[6, 'andere Quelle'],
], )
intpoluse = models.PositiveIntegerField(choices=[
[1, 'gar nicht'],
[2, '1 Tagen'],
[3, '2 Tage'],
[4, '3 Tage'],
[5, '4 Tage'],
[6, '5 Tage'],
[7, '6 Tage'],
[8, '7 Tage'],
], )
opiniondiff = models.PositiveIntegerField(choices=[
[1, 'Nie'],
[2, 'Selten'],
[3, 'Manchmal'],
[4, 'Oft'],
[5, 'Immer'],
], )
afdsupport = models.PositiveIntegerField(choices=[
[1, 'Niemand (0%)'],
[2, 'Ein paar (ca. 10%)'],
[3, 'Einige (ca. 25%)'],
[4, 'Ungefähr die Hälfte (ca. 50%)'],
[5, 'Viele von ihnen (ca. 75%)'],
[6, 'Alle (100%)'],
], )
rightleft = models.PositiveIntegerField(choices=[
[1, '1, links'],
[2, '2'],
[3, '3'],
[4, '4'],
[5, '5'],
[6, '6'],
[7, '7'],
[8, '8'],
[9, '9'],
[10, '10'],
[11, '11, rechts'],
[999, 'weiß nicht/ keine Angabe'],
], )
mayor = models.StringField(blank=True)
wallet = models.PositiveIntegerField(choices=[
[1, 'höchst wahrscheinlich'],
[2, 'eher wahrscheinlich'],
[3, 'wahrscheinlich'],
[4, 'eher unwahrscheinlich'],
[5, 'völlig unwahrscheinlich'],
[999, 'weiß nicht/ keine Angabe'],
], )
trustneighbor = models.PositiveIntegerField(choices=[
[1, 'sehr stark'],
[2, 'stark'],
[3, 'mittelmäßig'],
[4, 'weniger stark'],
[5, 'überhaupt nicht'],
[999, 'weiß nicht/ keine Angabe'],
], )
communitybelonging = models.PositiveIntegerField(choices=[
[1, 'Stark verbunden'],
[2, 'Ziemlich verbunden'],
[3, 'Wenig verbunden'],
[4, 'Gar nicht verbunden'],
[999, 'weiß nicht/ keine Angabe'],
], )
housing = models.PositiveIntegerField(choices=[
[1, 'zur Untermiete'],
[2, 'in einer Mietwohnung / in einem gemieteten Haus'],
[3, 'in einer Eigentumswohnung (Eigen- oder Familienbesitz)'],
[4, 'im eigenen Haus (oder dem Haus der Familie)'],
[5, 'Andere Wohnform'],
], )
income = models.PositiveIntegerField(min=0, max=100000)
feedback = models.CharField(
widget=forms.Textarea(attrs={
'rows': 3,
'cols': 70
}),
verbose_name="",
validators=[
MinLengthValidator(
10,
message="Bitte schreiben Sie mindestens 10 Wörter.",
),
])
# name = models.CharField(
# widget=forms.Textarea(attrs={'rows': 1, 'cols': 50}),
# verbose_name="",
# )
#
# street = models.CharField(
# widget=forms.Textarea(attrs={'rows': 1, 'cols': 50}),
# verbose_name="",
# )
#
# town = models.CharField(
# widget=forms.Textarea(attrs={'rows': 1, 'cols': 50}),
# verbose_name="",
# )
email1 = models.EmailField()
email2 = models.EmailField()
class Offer(djmodels.Model):
employer = djmodels.ForeignKey(Player, related_name='offers')
amount = models.IntegerField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Task(djmodels.Model):
player = djmodels.ForeignKey(to=Player, related_name='tasks')
question = ListField()
correct_answer = ListField()
digits = ListField()
letters = ListField()
answer = models.StringField(null=True)
page_index = models.IntegerField()
page_name = models.StringField(doc='page name of task submission',
null=True)
is_correct = models.BooleanField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
# todo: the following methods can and should be done through currying
# https://stackoverflow.com/questions/5730211/how-does-get-field-display-in-django-work
def get_str(self, field):
return ''.join(getattr(self, field))
def get_digits(self):
return self.get_str('digits')
def get_letters(self):
return self.get_str('letters')
def get_question(self):
return self.get_str('question')
def get_correct_answer(self):
return self.get_str('correct_answer')
def get_body(self):
return {
'question': self.question,
'digits': self.digits,
'letters': self.letters,
}
def decoding_dict(self):
keys = self.digits
values = self.letters
dictionary = dict(zip(keys, values))
return dictionary
def get_decoded(self, to_decode):
decdict = self.decoding_dict()
return [decdict[i] for i in to_decode]
def as_dict(self):
# TODO: clean the mess with the body
# TODO: remove correct answer when go into production
return {'correct_answer': self.correct_answer, 'body': self.get_body()}
@classmethod
def post_create(cls, sender, instance, created, *args, **kwargs):
if not created:
return
instance.page_index = instance.player.participant._index_in_pages
instance.page_name = instance.player.participant._url_i_should_be_on(
).strip().split('/')[-3]
digs = list(string.digits)
random.shuffle(digs)
instance.digits = digs
lts = random.sample(string.ascii_lowercase, k=Constants.num_letters)
instance.letters = lts
instance.question = random.choices(string.digits, k=Constants.task_len)
instance.correct_answer = instance.get_decoded(instance.question)
instance.save()
class Player(BasePlayer):
id_profile = models.PositiveIntegerField()
id_session = models.CharField()
id_born = models.PositiveIntegerField(choices=[
[1, 'A Milano'],
[2, 'In Italia, ma non a Milano'],
[3, 'Fuori dall’ Italia'],
], )
def permanent_var(self):
self.participant.vars['id_born'] = self.id_born
#self.participant.vars['id_profile'] = self.id_profile
#self.participant.vars['id_session'] = self.id_session
choices = models.CharField(
widget=widgets.RadioSelect(attrs={'readonly': 'readonly'}), )
#Pre Survey Questions
city = models.CharField()
residencetime = models.PositiveIntegerField(choices=[
[1, 'meno di un anno'],
[2, 'tra 1-3 anni'],
[3, '4-10 anni'],
[4, '11-15 anni'],
[5, '16-20 anni'],
[6, '21 anni o più'],
], )
region = models.CharField()
married = models.PositiveIntegerField(choices=[
[1, 'Single'],
[2, 'Sposato/a o convinvente'],
[3, 'Vedovo/a'],
[4, 'Separato/a o divorziato/a'],
], )
children = models.PositiveIntegerField(choices=[[1, 'No'],
[2, 'Si, 1 bambina/o'],
[3, 'Si, 2 bambini'],
[4, 'Si, 3 bambini'],
[5,
'Si, 4 bambini o più']], )
household = models.PositiveIntegerField(choices=[
[1, 'Vivo da solo/a'],
[2, 'Siamo in 2'],
[3, 'Siamo in 3'],
[4, 'Siamo in 4'],
[5, 'Siamo in 5'],
[6, 'Siamo in 6'],
[7, 'Siamo 7 o più'],
], )
wallet = models.PositiveIntegerField(choices=[
[1, 'Quasi certo'],
[2, 'Molto probabile'],
[3, 'Non molto probabile'],
[4, 'Per nulla probabile'],
], )
dec_risk = models.PositiveIntegerField(min=0, max=10)
accomodation = models.PositiveIntegerField(choices=[
[1, 'È in affitto'],
[2, 'È di mia proprietà '],
[3, 'È di mia proprietà e sto pagando il mutuo'],
[4, '(Non risponde)'],
], )
savings = models.PositiveIntegerField(choices=[
[1, 'Risparmiato soldi'],
[2, 'Guadagnato lo stretto necessario'],
[
3,
'Usato risparmi messi da parte in precedenza per le necessità quotidiane'
],
[4, 'Preso denaro a prestito per le necessità quotidiane'],
[5, '(Non sa)'],
[6, '(Non risponde)'],
], )
socialclass = models.PositiveIntegerField(choices=[
[1, 'Classe alta'],
[2, 'Classe medio-alta'],
[3, 'Classe medio-bassa'],
[4, 'Classe lavoratrice'],
[5, 'Classe bassa'],
[6, '(Non sa)'],
[7, '(Non risponde)'],
], )
income = models.PositiveIntegerField(choices=[
[1, 'Meno di 15.000 Euro'],
[2, 'da 15.001 a 20.000 Euro'],
[3, 'da 20.001 a 25.000 Euro'],
[4, 'da 25.001 a 30.000 Euro'],
[5, 'da 30.001 a 35.000 Euro'],
[6, 'da 35.001 a 40.000 Euro'],
[7, 'da 40.001 a 47.000 Euro'],
[8, 'da 47.001 a 58.000 Euro'],
[9, 'da 58.001 a 80.000 Euro'],
[10, 'da 80.001 a 100.000 Euro'],
[11, 'da 100.001 a 150.000 Euro'],
[12, 'oltre 150.000 Euro'],
[13, '(Non sa)'],
[14, '(Non risponde)'],
], )
attimm1 = models.PositiveIntegerField(choices=[
[1, 'Molto'],
[2, 'Abbastanza'],
[3, 'Poco'],
[4, 'Per niente'],
[5, '(Non sa)'],
], )
attimm2 = models.PositiveIntegerField(choices=[
[1, 'Molto'],
[2, 'Abbastanza'],
[3, 'Poco'],
[4, 'Per niente'],
[5, '(Non sa)'],
], )
attimm3 = models.PositiveIntegerField(choices=[
[1, 'Molto'],
[2, 'Abbastanza'],
[3, 'Poco'],
[4, 'Per niente'],
[5, '(Non sa)'],
], )
attimm4 = models.PositiveIntegerField(choices=[
[1, 'Molto'],
[2, 'Abbastanza'],
[3, 'Poco'],
[4, 'Per niente'],
[5, '(Non sa)'],
], )
attimm5 = models.PositiveIntegerField(choices=[
[1, 'Molto'],
[2, 'Abbastanza'],
[3, 'Poco'],
[4, 'Per niente'],
[5, '(Non sa)'],
], )
friendsimm = models.PositiveIntegerField(choices=[
[1, 'Nessuno'],
[2, 'Uno'],
[3, 'Da 2 a 5'],
[4, 'Da 6 a 10'],
[5, 'Più di 10'],
], )
aquaintnonit = models.PositiveIntegerField(choices=[
[1, 'Nessuno'],
[2, 'Uno'],
[3, 'Da 2 a 5'],
[4, 'Da 6 a 10'],
[5, 'Più di 10'],
], )
meetimm = models.PositiveIntegerField(choices=[
[1, 'Mai'],
[2, 'Raremente'],
[3, 'A volte'],
[4, 'Spesso'],
[5, 'Quasi sempre'],
], )
negcontact = models.PositiveIntegerField(choices=[
[1, 'Mai'],
[2, 'Raremente'],
[3, 'A volte'],
[4, 'Spesso'],
[5, 'Quasi sempre'],
], )
employimm = models.PositiveIntegerField(choices=[
[1, 'Si'],
[2, 'No'],
], )
employimmnationality = models.CharField(blank=True)
colleagues = models.PositiveIntegerField(choices=[
[1, 'Nessuno'],
[2, 'Uno'],
[3, 'Da 2 a 5'],
[4, 'Da 6 a 10'],
[5, 'Più di 10'],
], )
#Input task
dec_dg1 = models.PositiveIntegerField(min=0, max=10)
dec_dg2 = models.PositiveIntegerField(min=0, max=10)
dec_svoc = models.CharField(choices=['Partecipare', 'Non partecipare'],
widget=widgets.RadioSelect())
dec_svonc = models.CharField(choices=['Partecipare', 'Non partecipare'],
widget=widgets.RadioSelect())
dec_pdguess = models.CharField(choices=['Partecipare', 'Non partecipare'],
widget=widgets.RadioSelect())
dec_pdcertain = models.CharField(choices=[
'Molto sicuro', 'Abbastanza sicuro', 'Abbastanza incerto',
'Molto incerto'
],
widget=widgets.RadioSelect())
dec_pd1 = models.CharField(choices=['Partecipare', 'Non partecipare'],
widget=widgets.RadioSelect())
#dec_infosell = models.CharField(choices=['Si, regardless la sua decisione', 'Si, solo se ha scelto Partecipare', 'Si, solo se ha scelto di Non Partecipare', 'No'], widget=widgets.RadioSelect())
dec_infosell = models.CharField(choices=['Si', 'No'],
widget=widgets.RadioSelect())
dec_infobuy = models.CharField(choices=['Si', 'No'],
widget=widgets.RadioSelect())
dec_pd2 = models.CharField(choices=['Partecipare', 'Non partecipare'],
widget=widgets.RadioSelect())
dec_trustjob = models.PositiveIntegerField(min=0, max=10)
#dec_trustjob = models.PositiveIntegerField( choices = [0,1,2,3,4,5,6,7,8,9,10], widget=widgets.RadioSelect(attrs={'class': 'inline'}))
dec_trustcheckjob = models.PositiveIntegerField(min=0)
dec_trustestimjob = models.PositiveIntegerField(min=0)
dec_trustactivity = models.PositiveIntegerField(min=0, max=10)
# dec_trustactivity = models.PositiveIntegerField( choices = [0,1,2,3,4,5,6,7,8,9,10], widget=widgets.RadioSelect(attrs={'class': 'inline'}))
dec_trustcheckact = models.PositiveIntegerField(min=0)
dec_trustestimact = models.PositiveIntegerField(min=0)
dec_threat = models.CharField(choices=['Protetto', 'Non protetto'],
widget=widgets.RadioSelect())
dec_picknumber = models.PositiveIntegerField(min=1, max=10)
#Payoff
po_dg1 = models.CurrencyField()
po_dg2 = models.CurrencyField()
po_svoc = models.CurrencyField()
po_svonc = models.CurrencyField()
po_pdguess = models.CurrencyField()
po_pd1 = models.CurrencyField()
po_infosell = models.CurrencyField()
po_infobuy = models.CurrencyField()
po_pd2 = models.CurrencyField()
po_trustjob = models.CurrencyField()
po_trustact = models.CurrencyField()
po_threat = models.CurrencyField()
#Timers
starttime_questionnaire = models.DateTimeField()
starttime_task1 = models.DateTimeField()
starttime_task2 = models.DateTimeField()
starttime_task3 = models.DateTimeField()
starttime_task4 = models.DateTimeField()
starttime_task5 = models.DateTimeField()
starttime_lastpage = models.DateTimeField()
# Save ID Profile - done with Chiara
#dg_name1 = models.CharField() # created the variable to be stored
#dg_name2 = models.CharField()
#Initialize the variable
def init_var(self):
self.id_profile = self.participant.vars['id_profile']
self.id_session = self.participant.vars['id_session']
#self.dg_name1 = Constants.dg_name1[self.player.id_profile]
#self.dg_name2 = Constants.dg_name2[self.player.id_profile]
#Assign payoff: at the end condensed in a unique function!
def def_po_pdg1(self):
self.po_dg1 = self.dec_dg1
def def_po_pdg2(self):
self.po_dg2 = self.dec_dg2
def def_po_svo(self):
if self.dec_svoc == "Partecipare":
self.po_svoc = Constants.cc
else:
self.po_svoc = Constants.dc
if self.dec_svonc == "Partecipare":
self.po_svonc = Constants.cd
else:
self.po_svonc = Constants.dd
def def_po_pdguess(self):
if Constants.pd_altdec1[self.id_profile] == self.dec_pdguess:
self.po_pdguess = 8
else:
self.po_pdguess = 0
def def_po_pd1(self):
if Constants.pd_altdec1[self.id_profile] == "Partecipare":
if self.dec_pd1 == "Partecipare":
self.po_pd1 = Constants.cc
else:
self.po_pd1 = Constants.dc
else:
if self.dec_pd1 == "Partecipare":
self.po_pd1 = Constants.cd
else:
self.po_pd1 = Constants.dd
# def def_po_infosell(self):
# pass
#Write all when we have the actual answer for the question
#If yes and specific decision: -{{Constants.pd_infosell}}, otherwise: 0
def def_po_infobuy(self):
if self.dec_infobuy == "Si":
self.po_infobuy = -float(Constants.pd_infobuy)
else:
self.po_infobuy = 0
def def_po_trustjob(self):
self.po_trustjob = (10 - float(
self.dec_trustjob)) + float(self.dec_trustjob) * 3 * float(
Constants.trust_altdec1[self.id_profile])
def def_po_trustact(self):
self.po_trustact = (10 - float(self.dec_trustactivity)) + float(
self.dec_trustactivity) * 3 * float(
Constants.trust_altdec2[self.id_profile])
# def def_po_trust1(self):
# self.trust_job*3*float(Constants.trust_altdec1[self.id_profile])
def def_po_pd2(self):
if Constants.pd_altdec2[self.id_profile] == "Partecipare":
if self.dec_pd2 == "Partecipare":
self.po_pd2 = Constants.cc
else:
self.po_pd2 = Constants.dc
else:
if self.dec_pd2 == "Partecipare":
self.po_pd2 = Constants.cd
else:
self.po_pd2 = Constants.dd
def def_po_threat(self):
if Constants.threat_altdec[self.id_profile] == "Prendere":
if self.dec_threat == "Non protetto":
self.po_threat = -3
else:
self.po_threat = 0
else:
if self.dec_pd2 == "Non protetto":
self.po_threat = 5
else:
self.po_threat = 0
def pass_variables(self):
self.participant.vars['dec_dg1'] = self.dec_dg1
self.participant.vars['po_dg1'] = self.po_dg1
self.participant.vars['dec_dg2'] = self.dec_dg2
self.participant.vars['po_dg2'] = self.po_dg2
self.participant.vars['dec_svoc'] = self.dec_svoc
self.participant.vars['po_svoc'] = self.po_svoc
self.participant.vars['dec_svonc'] = self.dec_svonc
self.participant.vars['po_svonc'] = self.po_svonc
self.participant.vars['dec_pdguess'] = self.dec_pdguess
self.participant.vars['po_pdguess'] = self.po_pdguess
self.participant.vars['dec_pd1'] = self.dec_pd1
self.participant.vars['po_pd1'] = self.po_pd1
self.participant.vars['dec_pd2'] = self.dec_pd2
self.participant.vars['po_pd2'] = self.po_pd2
self.participant.vars['dec_trustjob'] = self.dec_trustjob
self.participant.vars['po_trustjob'] = self.po_trustjob
self.participant.vars['dec_trustactivity'] = self.dec_trustactivity
self.participant.vars['po_trustact'] = self.po_trustact
self.participant.vars['dec_threat'] = self.dec_threat
self.participant.vars['po_threat'] = self.po_threat
self.participant.vars['dec_infosell'] = self.dec_infosell
self.participant.vars['po_infosell'] = self.po_infosell
self.participant.vars['dec_infobuy'] = self.dec_infobuy
self.participant.vars['po_infobuy'] = self.po_infobuy
self.participant.vars['city'] = self.city
self.participant.vars['residencetime'] = self.residencetime
self.participant.vars['born'] = self.born
self.participant.vars['married'] = self.married
self.participant.vars['children'] = self.children
self.participant.vars['household'] = self.household
self.participant.vars['wallet'] = self.wallet
self.participant.vars['dec_risk'] = self.dec_risk
self.participant.vars['accomodation'] = self.accomodation
self.participant.vars['savings'] = self.savings
self.participant.vars['socialclass'] = self.socialclass
self.participant.vars['income'] = self.income
self.participant.vars['attimm1'] = self.attimm1
self.participant.vars['attimm2'] = self.attimm2
self.participant.vars['attimm3'] = self.attimm3
self.participant.vars['attimm4'] = self.attimm4
self.participant.vars['attimm5'] = self.attimm5
self.participant.vars['friendsimm'] = self.friendsimm
self.participant.vars['aquaintnonit'] = self.aquaintnonit
self.participant.vars['meetimm'] = self.meetimm
self.participant.vars['negcontact'] = self.negcontact
self.participant.vars['employimm'] = self.employimm
self.participant.vars[
'employimmnationality'] = self.employimmnationality
self.participant.vars['colleagues'] = self.colleagues
self.participant.vars['dec_picknumber'] = self.dec_picknumber
class Question(models.Model):
question_text = models.StringField(max_length=200)
pub_date = models.DateTimeField('date published')
def __str__(self):
return self.question_text
class Contract(djmodels.Model):
"""This model contains information about all contracts done during the trading session (aka round)."""
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
# the o2o field to item should be reconsidered if we make quantity flexible
item = djmodels.OneToOneField(to=Item)
bid = djmodels.OneToOneField(to=Bid)
ask = djmodels.OneToOneField(to=Ask)
price = djmodels.DecimalField(max_digits=Constants.price_max_numbers,
decimal_places=Constants.price_digits)
cost = models.CurrencyField()
value = models.CurrencyField()
def get_seller(self):
return self.ask.player
def get_buyer(self):
return self.bid.player
def __str__(self):
return '{}. Price:{}, Quantity:{}. BID by: {}. ASK BY: {}'. \
format(self.__class__.__name__, str(self.price), self.item.quantity, self.bid.player.id, self.ask.player.id)
@classmethod
def create(cls, item, bid, ask, price):
buyer = bid.player
seller = ask.player
cost = item.slot.cost
new_slot = buyer.get_free_slot()
item.slot = new_slot
value = new_slot.value
contract = cls(item=item,
bid=bid,
ask=ask,
price=price,
cost=cost,
value=value)
item.save()
Ask.active_statements.filter(player=seller).update(active=False)
Bid.active_statements.filter(player=buyer).update(active=False)
buyer.endowment -= contract.price
contract_parties = [buyer, seller]
contract.save()
for p in contract_parties:
p.set_payoff()
p.active = p.is_active()
p.save()
p_group = ChannelGroup(p.get_personal_channel_name())
p_group.send({
'text':
json.dumps({
'repo': p.get_repo_html(),
'contracts': p.get_contracts_html(),
'form': p.get_form_html(),
'profit': p.profit_block_html(),
'presence': p.presence_check(),
})
})
group = buyer.group
group_channel = ChannelGroup(group.get_channel_group_name())
group_channel.send(
{'text': json.dumps({'presence': group.presence_check()})})
for p in group.get_players():
group_channel = ChannelGroup(p.get_personal_channel_name())
group_channel.send({
'text':
json.dumps({
'asks': p.get_asks_html(),
'bids': p.get_bids_html()
})
})
return contract
class Item(djmodels.Model):
"""This is a repository of items people have for trading in the trading sessions."""
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
slot = djmodels.OneToOneField(to=Slot, related_name='item')
quantity = models.IntegerField()
class Player(BasePlayer):
order_id = models.IntegerField()
comment = models.StringField()
img_id = models.IntegerField()
comment_subject_id = models.IntegerField()
q1 = models.StringField(
initial=None,
choices=[('1', 'sehr freundlich'), ('2', '2'), ('3', '3'), ('4', '4'),
('5', '5'), ('6', '6'), ('7', '7'), ('8', '8'),
('9', 'sehr feindselig'),
('Nicht zu bewerten', 'Nicht zu bewerten')],
verbose_name=
'Ist der Kommentar freundlich oder feindselig gegenüber der im Foto dargestellten Gruppe? ',
widget=widgets.RadioSelectHorizontal())
against_other = models.StringField(
initial=None,
choices=[
'Nein', 'Ja, er ist zustimmend', 'Ja, er ist ablehnend',
'Nicht zu bewerten'
],
verbose_name='Richtet sich der Kommentar an einen anderen Nutzer?',
widget=widgets.RadioSelectHorizontal())
should_allow = models.StringField(
initial=None,
choices=['Nein', 'Ja', 'Ich weiß nicht'],
verbose_name=
'Sollte dieser Kommentar in einem Internetforum erlaubt sein?',
widget=widgets.RadioSelectHorizontal())
c_1 = models.CharField(widget=widgets.CheckboxInput(),
blank=True,
verbose_name='Beinhaltet negative Vorurteile')
c_2 = models.CharField(widget=widgets.CheckboxInput(),
blank=True,
verbose_name='Nutzt rassistische Beleidigungen')
c_3 = models.CharField(
widget=widgets.CheckboxInput(),
blank=True,
verbose_name=
'Beinhaltet beleidigende, erniedrigende oder abwertende Worte')
c_4 = models.CharField(
widget=widgets.CheckboxInput(),
blank=True,
verbose_name='Ruft zu Gewalt, Drohungen oder Diskriminierung auf')
c_5 = models.CharField(widget=widgets.CheckboxInput(),
blank=True,
verbose_name='Nutzt sexistische Beleidigungen')
c_6 = models.CharField(
widget=widgets.CheckboxInput(),
blank=True,
verbose_name=
'Die sexuelle Orientierung oder das Geschlecht/Gender wird herabgesetzt oder stigmatisiert'
)
# For the layout
ceiling_rounds = models.IntegerField()
displayed_rounds = models.IntegerField()
# Control variable
current_time = models.DateTimeField()
# treatments
pop_uncertain = models.BooleanField()
group_size = models.StringField()
# If we the person was admitted to the treatments or blocked because we
# are full
admit = models.BooleanField()
# Outcome variable
volunteer_decision = models.BooleanField()
def current_question(self):
return self.participant.vars['comments'][self.round_number - 1]
def get_time_diff(self):
time_end = self.in_round(Constants.vod_round).current_time
start_time = self.participant.vars['time_start']
time_task = time_end - start_time
return time_task
def is_playing(self):
pass
def get_additional_constants(self):
""" A function which returns constants stored in the config for the template"""
group_key = self.participant.vars['group_size']
pop_unc = self.participant.vars['pop_uncertain']
spread = Constants.group_dict[group_key]['spread']
mean_group_size = Constants.group_dict[group_key]['mean']
lb_group_size = mean_group_size - spread
ub_group_size = mean_group_size + spread
baseline_fee = self.session.config['participation_fee']
vod_bonus = self.session.config['vod_bonus']
return {
'mean_group_size': mean_group_size,
'ub_group_size': ub_group_size,
'lb_group_size': lb_group_size,
'baseline_fee': baseline_fee,
'vod_bonus': vod_bonus,
'pop_uncertain': pop_unc
}
def assign_treatment(self):
prob_list, total_missing = self.calc_probs()
# If there are no spots to fill, set the *admit* variable to false to
# block the participants
if total_missing > 0:
treatments, probs = zip(*prob_list)
treatments_list = list(treatments)
# because numpy is weird when drawing from a list of tuples we do
# it like this:
random_index = int(np.random.choice(len(treatments), 1, p=probs))
treatment = treatments[random_index]
# assign treatment according to random draw
self.group_size, self.pop_uncertain = treatment
# Also save in the participant dict
self.participant.vars['pop_uncertain'] = self.pop_uncertain
self.participant.vars['group_size'] = self.group_size
self.admit = True
else:
self.session.vars['admit'] = False
self.admit = False
def calc_probs(self):
prob_list = []
missing_treatments = {}
total_missing = 0
for key in Constants.group_dict.keys():
missing_treatments[key] = {}
diff_cert = Constants.group_dict[key]['threshold_cert'] - \
self.session.vars[key]['finished_cert']
diff_unc = Constants.group_dict[key]['threshold_unc'] - \
self.session.vars[key]['finished_unc']
# If players join at the same time a lot it can happen that
# threshold_cert< finished_cert
if diff_cert < 0:
missing_treatments[key]['cert'] = 0
else:
missing_treatments[key]['cert'] = diff_cert
if diff_unc < 0:
missing_treatments[key]['unc'] = 0
else:
missing_treatments[key]['unc'] = diff_unc
total_missing = missing_treatments[key]['cert'] + \
missing_treatments[key]['unc'] + total_missing
for key in Constants.group_dict.keys():
if total_missing > 0:
current_prob_cert = missing_treatments[key]['cert'] / \
total_missing
current_prob_unc = missing_treatments[key]['unc'] / \
total_missing
# If players join at the same time a lot it can happen that
# threshold_cert< finished_cert
if current_prob_cert < 0:
current_prob_cert = 0
if current_prob_unc < 0:
current_prob_cert = 0
else:
current_prob_cert = 0
current_prob_unc = 0
# Append the probability for population uncertainty for the given
# group size
prob_list.append(((key, True), current_prob_unc))
# The same for non population uncertainty
prob_list.append(((key, False), current_prob_cert))
return prob_list, total_missing
def increase_counter(self):
key = self.participant.vars['group_size']
if self.participant.vars['pop_uncertain'] is True:
self.session.vars[key][
'finished_unc'] = self.session.vars[key]['finished_unc'] + 1
if self.participant.vars['pop_uncertain'] is False:
self.session.vars[key][
'finished_cert'] = self.session.vars[key]['finished_cert'] + 1
class TimeAwareInSessionRecord(Model):
timestamp = models.DateTimeField(default=timezone.now)
trigger_event_type = models.CharField()
event_no = models.IntegerField()
subsession_id = models.IntegerField()
market_id = models.IntegerField()
class Item(djmodels.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
slot = djmodels.OneToOneField(to=Slot, related_name='item')
quantity = models.IntegerField()
class Contract(djmodels.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
# the o2o field to item should be reconsidered if we make quantity flexible
# item = djmodels.OneToOneField(to=Item)
bid = djmodels.OneToOneField(to=Bid)
ask = djmodels.OneToOneField(to=Ask)
quantity = models.IntegerField()
price = djmodels.DecimalField(max_digits=Constants.price_max_numbers,
decimal_places=Constants.price_digits)
cost = models.CurrencyField()
value = models.CurrencyField()
def get_seller(self):
return self.ask.player
def get_buyer(self):
return self.bid.player
def __str__(self):
return '{}. Price:{}, Quantity:{}. BID by: {}. ASK BY: {}'. \
format(self.__class__.__name__, str(self.price), 1, self.bid.player.id, self.ask.player.id)
@classmethod
def create(cls, bid, ask, price):
# print("??????????????? contract creating 0")
buyer = bid.player
seller = ask.player
contract = cls(bid=bid,
ask=ask,
price=price,
value=0,
quantity=1,
cost=0)
Ask.active_statements.filter(player=seller).update(active=False)
Bid.active_statements.filter(player=buyer).update(active=False)
# print("??????????????? contract creating 1")
seller.num_share -= 1
buyer.num_share += 1
buyer.endowment -= price
seller.endowment += price
# print("??????????????? contract creating 2")
contract_parties = [buyer, seller]
contract.save()
# print("??????????????? contract creating 3")
for p in contract_parties:
# p.set_payoff()
p.active = p.is_active()
p.save()
p_group = ChannelGroup(p.get_personal_channel_name())
p_group.send({
'text':
json.dumps({
'repo': p.get_repo_html(),
'contracts': p.get_contracts_html(),
'form': p.get_form_html(),
'ask_form': p.get_ask_form_html(),
'bid_form': p.get_bid_form_html(),
'best_ask_form': p.get_best_ask_form_html(),
'profit': p.profit_block_html(),
'presence': p.presence_check(),
})
})
group = buyer.group
group_channel = ChannelGroup(group.get_channel_group_name())
group_channel.send(
{'text': json.dumps({'presence': group.presence_check()})})
for p in group.get_players():
group_channel = ChannelGroup(p.get_personal_channel_name())
group_channel.send({
'text':
json.dumps({
'asks': p.get_asks_html(),
'bids': p.get_bids_html()
})
})
return contract
class Question(models.Model):
question_text = models.StringField(max_length=200)
pub_date = models.DateTimeField('date published')
