def make_wager(team_name, username, description, points, position, minutes):
if 1 > points:
return f"`{points}` is a terrible failure. All wagers must be positive integers.\n" \
f"Usage: `!wager <points> <Description>`\n" \
f"If you'd like to bet something will not happen reflect that in the description."
if points > 5001:
return f"`{points}` is a terrible failure. All wagers must be positive integers less than 5001.\n" \
f"Usage: `!wager <points> <Description>`\n" \
f"If you'd like to bet something will not happen reflect that in the description."
team, user = get_team_user(team_name, username)
existing_wager = team.wager_exists(description)
exists = False
for w in existing_wager:
if w.description == description:
exists = True
return f"Wager: `#{w.id}` {w.description} already exists.\n" \
f"```Usage: !bet <#wager> <points> <True/False>```"
if not exists:
end_time = datetime.now() + timedelta(minutes=minutes)
bet = Bet(points=points, position=position)
wager = Wager(team_id=team.id, description=description, points=points, start_time=datetime.now(), end_time=end_time)
bet.wager = wager
user.bets.append(bet)
s.commit()
msg = f'Wager: `#{wager.id}`\n"{wager.description}"\n' \
f'{get_wager_bets(wager)}'
s.close()
payload = {"msg": msg, "wager_id": wager.id}
return payload
def make_bet(team_name, username, points, position, wager_id):
if points < 1:
return "You can't bet negative points."
if points > 5000:
return "5000 is the max bet."
team, user = get_team_user(team_name, username)
wager = s.query(Wager).get(wager_id)
msg = ""
if wager:
if wager.team_id != team.id:
return f'This team is not able to access wager `#{wager.id}`.'
if wager.is_closed:
return f'Wager: `#{wager.id}` "{wager.description}" is closed for betting.'
if bet := wager.already_bet(user):
print(bet)
return f"Wager `#{wager.id}`: {wager.description}\n" \
f"{get_wager_bets(wager)}" \
# f"\n\n{user.username} already wagered `{bet.points}` `#{wager.id}` will be `{bet.position}`.\n"
if points > wager.bets[0].points:
return f"You can't bet more than {wager.bets[0].points} on wager `#{wager.id}`"
else:
bet = Bet(points=points, position=position)
bet.wager = wager
bet.user = user
s.add(bet)
s.commit()
msg += f'Wager: `#{wager.id}` "{wager.description}"\n'
msg += get_wager_bets(wager)
# msg += f'\n@{user.username} your bet has been recorded.\n'
s.close()
return msg
def post(self):
try:
jsondata = json.loads(self.request.body)
except UnicodeDecodeError:
jsondata = json.loads(self.request.body,encoding='latin-1')
formkey = ndb.Key(urlsafe=jsondata['form_key'])
form = formkey.get()
#if authenticated
if bool(jsondata['auth']):
session = Session.last_from_username(jsondata['user'])
avatar = session[0].avatar
else:
avatar = 'http://betweetdotnet.appspot.com/img/default.jpg'
bet = Bet(parent = formkey,
description = form.description,
user = jsondata['user'],
fields = jsondata['fields'],
authenticated = bool(jsondata['auth']),
avatar = avatar)
bet.put()
def place_bet(request):
evt = Event.objects.get(id = request.POST.get("event_id"))
player = Player.objects.get(id = request.POST.get("player_id"))
bet_amount = request.POST.get("amount")
current_user = User.objects.get(id= request.POST.get("user_id"))
ror = request.POST.get("return_rate")
bet = Bet(event = evt, player = player, amount = bet_amount, rate_of_return = ror, user = current_user)
bet.save()
return HttpResponse("<html><body>Enjoy betting you sucker</body></html>")
def processEnterBetForm(request, betForm, gamename):
user = request.user
targetname = betForm.data['target']
examname = betForm.data['exam']
guessmark = betForm.data['guess_mark']
guesscredits = betForm.data['guess_credits']
try:
int(guessmark)
except:
return "Your prediction must be a whole number from 0 to 100."
try:
int(guesscredits)
except:
return "You cannot use decimal credits."
if (str(targetname) == "" or str(examname) == "" or str(guessmark) == ""
or str(guesscredits) == ""):
return 'Make sure you have chosen an exam, a target,a mark and an amount of credits!'
examid = extractExamIDgivenGroup(examname, gamename)
targetid = getUserID(targetname)
if not (int(guessmark) >= 0 and int(guessmark) <= 100):
return 'Predicted mark invalid. Make sure it is between 0 and 100!'
groupid = extractGroupId(gamename)
credits = GroupMember.objects.get(group_id=groupid,
user_id=getUserID(user))
if int(credits.credits) < int(guesscredits):
return 'You do not have enough credits.'
elif int(guesscredits) <= 0:
return 'You must use at least 1 credit.'
exam = Exam.objects.get(pk=examid)
target = User.objects.get(pk=targetid)
if Bet.objects.filter(user=user, target=target, exam=exam).count() != 0:
return 'You have aleady made a bet on that user for this exam.'
resultEnteredCount = Result.objects.filter(exam_id=examid,
user_id=targetid).count()
if resultEnteredCount > 0:
return str(
target
) + ' has already entered their mark for this exam. You cannot place any further bets!'
newBet = Bet(exam=exam,
user=request.user,
target=target,
guess_mark=guessmark,
guess_credits=guesscredits)
groupid = extractGroupId(gamename)
credits = GroupMember.objects.get(group_id=groupid,
user_id=getUserID(user))
if int(credits.credits) < int(guesscredits):
return 'Not enough credits!'
elif int(guesscredits) <= 0:
return 'Minimum amount of credits to bet is 1!'
newBet.save()
credits.credits = int(credits.credits) - int(guesscredits)
credits.save()
return False
def parse_row(self, a, row):
safea = a.string.encode('ascii', 'replace')
score = re.search("[0-9]\-[0-9]", safea)
source = self.url
if score is not None:
current_score = score.group()
teams = safea.partition(' %s ' % current_score)
else:
teams = safea.partition(' vs ')
team_a = teams[0]
team_b = teams[2]
match_date = row.td.a
if match_date is None:
match_date = row.td.div
match_date = match_date['title']
# empty rows:
team_a_raw_odds = row.find('td', {'class' : 'odds'})
if team_a_raw_odds == None:
raise UnparsableException("Odds not found found for first team")
return 0
team_b_raw_odds = row.find('td', {'class' : 'odds noBorder '})
if team_b_raw_odds == None:
return 0
draw_raw_odds = row.find('td', {'class' : 'odds noBorder'})
if draw_raw_odds == None:
return 0
team_a_odds = self.calc_odds(team_a_raw_odds.a.string.strip().encode('ascii', 'replace'))
team_b_odds = self.calc_odds(team_b_raw_odds.a.string.strip().encode('ascii', 'replace'))
draw_odds = self.calc_odds(draw_raw_odds.a.string.strip().encode('ascii', 'replace'))
matchup = Matchup.all().filter('team_a_name = ', team_a).filter('team_b_name', team_b)
result = matchup.fetch(1);
date_match_formatted = parse_date(match_date.split())
if len(result) == 0:
matchup = Matchup(team_a_name = team_a, team_b_name = team_b,
source = source, date_match = match_date, date_match_formatted = date_match_formatted
)
matchup.put()
else:
matchup = result[0]
bet = Bet(team_a_odds = team_a_odds, team_b_odds = team_b_odds,
draw_odds = draw_odds,
match = matchup
)
bet.put()
def get(self):
w = self.response.out
team_a = self.request.get('team_a')
team_b = self.request.get('team_b')
if team_a == "":
w.write('illegal request, need name for team a')
return
if team_b == "":
w.write('illegal request, need name for team b')
return
matches = Matchup.all().filter('team_a_name = ', team_a).filter('team_b_name = ', team_b).fetch(1)
if len(matches) == 0:
w.write('no matches found')
return
match = matches[0]
w.write("<h1>%s vs %s</h1>" % (match.team_a_name, match.team_b_name))
w.write("<div>Match date: %s </div>" % match.date_match_formatted)
bets = Bet.all().filter('match = ', match).fetch(1000)
w.write("<table>")
w.write("<tr><td>%s</td><td>Draw</td><td>%s</td><td>Recorded on</td><td>Current score</td></tr>" % (match.team_a_name, match.team_b_name))
for b in bets:
w.write("<tr>")
w.write("<td>%s</td>" % b.team_a_odds)
w.write("<td>%s</td>" % b.draw_odds)
w.write("<td>%s</td>" % b.team_b_odds)
w.write("<td>%s</td>" % b.date_recorded)
w.write("<td>%s</td>" % b.current_score)
w.write("</tr>")
w.write("</table>")
w.write('found %s bets' % len(bets))
def place_post():
category_id = request.form.get('id')
bet = request.form.get('bet')
bet_left = request.form.get('bet1')
if not bet.isdigit():
flash('Sua aposta contém caracteres inválidos', 'error')
elif int(bet) > current_user.pnkoins or int(bet) <= 0:
flash('Você não tem PnKoins suficientes', 'error')
elif int(bet) > Category.query.filter_by(id=category_id).first().max_bet:
flash('Sua aposta excede a aposta máxima para este evento', 'error')
else:
option_query = Option.query.filter_by(category_id=category_id).all()
option = option_query[1] if bet_left is None else option_query[0]
bet_obj = Bet.query.filter_by(user_id=current_user.id,
option_id=option.id,
category_id=category_id).first()
if bet_obj is not None:
flash('Aposta duplicada', 'error')
else:
new_bet = Bet(user_id=current_user.id,
option_id=option.id,
category_id=category_id,
value=int(bet))
current_user.pnkoins -= int(bet)
db.session.add(new_bet)
current_user.last_login = func.now()
db.session.commit()
flash('Aposta feita com sucesso', 'success')
return redirect(url_for('main.profile'))
def place_bet(request):
data = json.loads(request.body)
evt = Event.objects.get(id = data.get("event_id"))
player = Player.objects.get(id = data.get("player_id"))
bet_amount = data.get("amount")
current_user = request.user
ror = Player_event.objects.get(event_id=data.get("event_id"),player_id=data.get("player_id")).rate_of_return
total_bet_amount = float(bet_amount)*float(ror)
evt.total_bet_amount += total_bet_amount
evt.save()
if(check_if_more_betting_allowed(data.get("event_id"))):
bet = Bet(event = evt, player = player, amount = bet_amount, rate_of_return = ror, user = current_user)
bet.save()
return HttpResponse("<html><body>Enjoy betting you sucker</body></html>")
else:
return HttpResponse("<html><body>betting closed for this event</body></html>")
def __parseEventElementParamValue(self, event, elementHeader, xml):
if elementHeader != "":
betCoef = xml.xpath( "//text()" )
betCoef = u"".join( str( lstElem ).strip() for lstElem in betCoef )
betValue = 0
val = betCoef.find("(")
if val > -1:
val2 = betCoef.find(")")
if val2 > -1:
betValue = float( betCoef[val + 1:val2] )
betCoef = betCoef[val2 + 1:]
bet = Bet()
bet.coef = elementHeader
bet.odds_decimal = betCoef
bet.odds_value = betValue
event.addBet( bet )
def create_bet(created_by, bet, rate):
"""
Creates a currency for the user. Returns the created currency or None if not exists.
"""
bet = Bet(created_by=created_by, bet=bet, rate=rate)
session.add(bet)
session.commit()
return bet
def bet_add():
if not request.json or not 'stake' in request.json or len(
request.json['lines']) == 0:
abort(400)
bet = Bet()
bet.user_id = current_user.get_id()
bet.stake = request.json['stake']
bet.timestamp = datetime.utcnow()
db.session.add(bet)
db.session.commit()
for line in request.json['lines']:
bt = BetTip(bet_id=bet.id, tip_id=line['id'])
db.session.add(bt)
db.session.commit()
return jsonify({'success': True})
def create():
form = CreateBetForm()
if form.validate_on_submit():
with transaction() as tx:
bet = Bet(title=form.name.data,
description=form.description.data,
owner=current_user)
tx.add(bet)
for t in form.outcomes.entries:
tx.add(Outcome(title=t.data, bet=bet))
return redirect(url_for('bets.bet', bet_id=bet.bet_id))
return render_template("bets/create.html", create_form=form)
def raise_bet(day):
y, m, d = [int(x) for x in day.split("-")]
a = session.get('id')
if 'api_key' in request.values:
spac = Spac.all().filter('api_key =', request.values.get('api_key')).get()
if spac:
a = spac.key().name()
if not a:
abort(404)
day = Day.get_day(y, m, d)
try:
by = float(request.values["by"])
except:
abort(500, "Raise by what?")
try:
value = float(request.values["value"])
except:
abort(500, "Bet on what value?")
try:
Bet.raise_bet(a, day, by=by, value=value)
except Exception, e:
return "Error: could not raise bet. (%s)" % e
def bet_2_5sec(user, exchange_5sec, round_2_5sec):
new_bet = Bet(
user_id=user.id,
round_id=round_2_5sec.id,
bet_type=BetType.RISE,
bet_result=BetResult.PENDING,
amount=1000000,
commission=100000,
created_at=datetime(2000, 1, 1, 0, 5, 15),
)
db.session.add(new_bet)
db.session.commit()
yield new_bet
def get(self):
if self.request.get('user'):
creator = self.request.get('user')
forms = Bet.from_user(creator)
if forms:
betslist = json.dumps([f.to_dict_key() for f in forms])
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(betslist)
else:
self.abort(404)
else:
self.abort(404)
def post(self, request, username):
form = BetForm(self.request.POST)
if form.is_valid():
ser = User.objects.get(username=username)
match = Match.objects.get(id=form.cleaned_data['match'])
print 'form = %r' % form
bet = Bet(
user = user,
match = match,
scoreA = form.cleaned_data['scoreA'],
scoreB = form.cleaned_data['scoreB'],
triesA = form.cleaned_data['triesA'],
triesB = form.cleaned_data['triesB'],
card = form.cleaned_data['card'],
drop_goal = form.cleaned_data['drop_goal'],
fight = form.cleaned_data['fight'],
created_date= timezone.now()
)
bet.save()
return HttpResponseRedirect('/user/'+username+'/')
else:
print 'form = %r' % form
return render(request, 'betcup.html', {'form': form})
def syncBetTable(self):
data = {}
objects = []
for bet in Bet.filter(synced = False):
obj = {'ticket':bet.ticket.id,'odd':str(bet.odd.iid)}
bet.synced = True
bet.save()
objects.append(obj)
data['name'] = objects
request = Request(url='http://'+self.URL+'/sync/bet',data=json.dumps(data))
try:
urlopen(request).read()
except HTTPError, err:
pass
def bet(user_identifier, bet_amount, alternative):
user = db.session.query(User).filter(
User.user_identifier == user_identifier).one()
user.balance -= bet_amount
db.session.commit()
roulette_round = db.session.query(Roulette).filter(
Roulette.id == 1).one().current_round
user_bet = Bet(bet_amount, user.steamid, alternative, roulette_round)
db.session.add(user_bet)
db.session.commit()
def run():
while True:
status = WALLET.getStatus()
height = status['blockCount']
race_start = round_down(WALLET.getStatus()['blockCount'])
race = height // RACELENGTH
blocks_left = RACELENGTH - (height - race_start)
if blocks_left == 1: # we want a gap block, where no more bets are read in
continue
if blocks_left == 30: # race ended, find winner and pay out
pot = get_pot(race)
insert_winner(race, pot)
transactionData = WALLET.getTransactions(
{'firstBlockIndex':
race_start - 1}) # include bets from previous gap block
for item in transactionData['result']['items']:
for tx in item['transactions']:
if tx['paymentId'] == '':
continue
if tx['transaction_hash'] in CONFIRMED_TXS:
continue
if tx['unlockTime'] == 0:
CONFIRMED_TXS.append({
'txid': tx['transaction_hash'],
'parsed': False
})
for tx in CONFIRMED_TXS:
if tx['parsed']:
continue
data = WALLET.getTransaction({'transactionHash': tx})
# remove invalid bets
try:
turtle = int(data['paymentId'][-1:])
# bet was invalid
if turtle > 7:
continue
except ValueError: # bet was invalid
continue
bet = Bet(race_id=race,
bet_on=turtle,
amount=data['amount'],
payment_id=data['paymentId'])
tx['parsed'] = True
print(tx)
def get(self):
betalinger = []
status = False
qry = Bet.all().filter('Summabogfort !=', True)
for bet in qry:
for betlin in bet.listBetlin:
if betlin.Fakref:
if betlin.Fakref.SFaknr > 0:
betalinger.append(betlin)
status = True
template_values = {
'status': status,
'betalinger': betalinger,
}
path = os.path.join(os.path.dirname(__file__), 'templates/bogforindbetalinger.xml')
self.response.out.write(template.render(path, template_values))
def get(self):
w = self.response.out
offset = self.request.get('offset')
limit = self.request.get('limit')
if limit is "":
limit = 100
if offset is "":
offset = 0
limit = int(limit)
offset = int(offset)
matches = Matchup.all()[offset:limit+offset]
for m in matches:
bets = Bet.all().filter("match = ", m)
for b in bets:
template = "%s;%s;%s;%s;%s;%s;%s" % (m.team_a_name, m.team_b_name, b.team_a_odds, b.team_b_odds,b.draw_odds,m.date_match_formatted, b.date_recorded)
w.write(template)
w.write("<br/>")
def lust_bet_repeet(message):
user = User.get_user(message.from_user.id)
last_bet = Bet.objects.filter(user=user).order_by('-date').first()
bet_size = last_bet.bet_size
bet_numbers = last_bet.bet_numbers
bet_type = last_bet.bet_type
Bet(user=user,
bet_size=bet_size,
bet_numbers=bet_numbers,
bet_type=bet_type,
date=time.strftime("%y.%m.%d (%H:%M:%S)")).save()
print('New bet from:' + str(user.nickname))
if bet_type == 'Число(а)':
bet_type = ''
for number in bet_numbers:
bet_type += f'{number}'
bot.send_message(message.chat.id,
text=f'Ставка принята: {bet_size}$ на "{bet_type}"\n'
f'Ждите пока шарик остановится')
def post(self):
request_data = json.loads(self.request.body)
logging.info(request_data)
player = current_user_player()
match_key = ndb.Key(Match, int(request_data['match_id']))
match = match_key.get()
match_player = MatchPlayer.query(MatchPlayer.match == match_key, MatchPlayer.player == player.key).get()
if match.state() == "finished":
error_400(self.response, "ERROR_FINISHED_GAME", "You can not bet on a finished game.")
return
if not validate_request_data(self.response, request_data, ['match_id', 'bet']):
return
if not match_player:
error_400(self.response, "ERROR_NOT_OWN_GAME", "You have to bet on your own game.")
return
if request_data['bet']['id']:
bet = Bet.get_by_id(int(request_data['bet']['id']))
else:
bet = Bet(match=match_key, player=player.key, winning_faction=match_player.faction)
new_bet_value = int(request_data['bet']['value'])
bet_value_dif = new_bet_value - bet.value
if bet_value_dif < 0:
error_400(self.response, "ERROR_BET_LOWER", "Your new bet %s is lower than your previous bet %s" % (new_bet_value, bet.value))
return
if bet_value_dif > player.cash:
error_400(self.response, "ERROR_NOT_ENOUGH_CASH", "Not enough cash. Your player has %s cash and your new bet requires %s" % (player.cash, bet_value_dif))
return
bet.value = new_bet_value
bet.put()
player.cash -= bet_value_dif
player.put()
client_object_path = "player.matches.[%s].bets.[%s]" % (match_key.id(), bet.key.id())
match.websocket_notify_players("Match_UpdatedOrNewBet", client_object_path, bet.get_data(), player.key)
set_json_response(self.response, {'bet': bet.get_data(), 'cash': player.cash})
def raise_bet2(a, y, m, d, by):
day = Day.get_day(y, m, d)
Bet.raise_bet(a, day, by, value=float(request.values.get("value", "0.0")))
return "done"
def bet_saver(call):
roulette_kb = ReplyKeyboardMarkup(resize_keyboard=True, row_width=2)
roulette_kb.add('Повторить', 'На что то другое', 'Новая ставка',
'Изменить сумму ставки', 'В главное меню')
user = User.get_user(call.from_user.id)
bet_size = call.data.split('_')[1]
call_bet_type = call.data.split("_")[2]
if call_bet_type == '⚫':
bet_type = call_bet_type
bet_numbers = [
2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35
]
in_message_bet = bet_type
elif call_bet_type == '🔴':
bet_type = call_bet_type
bet_numbers = [
1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36
]
in_message_bet = bet_type
elif call_bet_type == 'Четные':
bet_type = call_bet_type
bet_numbers = [
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36
]
in_message_bet = bet_type
elif call_bet_type == 'Нечетные':
bet_type = call_bet_type
bet_numbers = [
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35
]
in_message_bet = bet_type
elif call_bet_type == '1-18':
bet_type = call_bet_type
bet_numbers = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
in_message_bet = bet_type
elif call_bet_type == '19-36':
bet_type = call_bet_type
bet_numbers = [
19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36
]
in_message_bet = bet_type
elif call_bet_type == '1-12':
bet_type = call_bet_type
bet_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
in_message_bet = bet_type
elif call_bet_type == '13-24':
bet_type = call_bet_type
bet_numbers = [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
in_message_bet = bet_type
elif call_bet_type == '25-36':
bet_type = call_bet_type
bet_numbers = [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
in_message_bet = bet_type
else:
str_bet_numbers = call_bet_type.split(',')
bet_numbers = []
for n in str_bet_numbers:
bet_numbers.append(int(n))
bet_type = 'Число(а)'
in_message_bet = call_bet_type
Bet(user=user,
bet_size=bet_size,
bet_numbers=bet_numbers,
bet_type=bet_type,
date=time.strftime("%y.%m.%d (%H:%M:%S)")).save()
print('New bet from:' + str(user.nickname))
bot.send_message(
call.message.chat.id,
text=f'Ставка принята: {bet_size}$ на "{in_message_bet}"\n'
f'Ждите пока шарик остановится',
reply_markup=roulette_kb)
def init_bets() -> List[Bet]:
"""Bet initializer."""
return [Bet(**bet) for bet in BET_TYPES]
def read042(self, sektion, transkode, rec):
fortegn = None
belobmun = None
belob = None
# -- pbssektionnr
# -- pbstranskode
# - transkode 0236, gennemført automatisk betaling
# - transkode 0237, afvist automatisk betaling
# - transkode 0238, afmeldt automatisk betaling
# - transkode 0239, tilbageført betaling
# -- debitorkonto
if sektion == '0211':
Nr = int(rec[33:40] )
Debitorkonto = rec[25:40]
elif sektion == '0215':
Nr = int(rec[37:44] )
Debitorkonto = rec[29:44]
else:
Nr = None
Debitorkonto = None
betlinid = nextval('Betlinid')
root_betlin = db.Key.from_path('Persons','root','Person','%s' % (Nr))
self.m_rec_betlin = Betlin.get_or_insert('%s' % (betlinid), parent=root_betlin)
self.m_rec_betlin.Id = betlinid
self.m_rec_betlin.Pbssektionnr = sektion
self.m_rec_betlin.Pbstranskode = transkode
self.m_rec_betlin.Nr = Nr
self.m_rec_betlin.Debitorkonto = Debitorkonto
# -- aftalenr
if sektion == '0211':
self.m_rec_betlin.Aftalenr = int(rec[40:49] )
else:
self.m_rec_betlin.Aftalenr = None
# -- pbskortart
if sektion == '0215':
self.m_rec_betlin.Pbskortart = rec[44:46]
else:
self.m_rec_betlin.Pbskortart = None
# -- pbsgebyrbelob
if sektion == '0215':
fortegn = int(rec[46:46+1] )
belob = int(rec[47:47+5] )
belobmun = float(belob / 100)
if fortegn == 0:
self.m_rec_betlin.Pbsgebyrbelob = float(0)
elif fortegn == 1:
self.m_rec_betlin.Pbsgebyrbelob = belobmun
else:
self.m_rec_betlin.Pbsgebyrbelob = float(0)
else:
self.m_rec_betlin.Pbsgebyrbelob = float(0)
# -- betalingsdato
if sektion == '0211':
if rec[49:55] != '000000':
self.m_rec_betlin.Betalingsdato = datetime.strptime('20' + rec[53:55] + '-' + rec[51:53] + '-' + rec[49:51], "%Y-%m-%d").date()
else:
self.m_rec_betlin.Betalingsdato = None
elif sektion == '0215':
if rec[52:58] != '000000':
self.m_rec_betlin.Betalingsdato = datetime.strptime('20' + rec[56:58] + '-' + rec[54:56] + '-' + rec[52:54], "%Y-%m-%d").date()
else:
self.m_rec_betlin.Betalingsdato = None
else:
self.m_rec_betlin.Betalingsdato = None
# -- belob
if sektion == '0211':
fortegn = int(rec[55:56] )
belob = int(rec[56:69] )
belobmun = float(belob / 100)
if fortegn == 0:
self.m_rec_betlin.Belob = float(0)
elif fortegn == 1:
self.m_rec_betlin.Belob = belobmun
elif fortegn == 2:
self.m_rec_betlin.Belob = (belobmun * -1)
else:
self.m_rec_betlin.Belob = None
elif sektion == '0215':
fortegn = int(rec[58:59] )
belob = int(rec[59:72] )
belobmun = float(belob / 100)
if fortegn == 0:
self.m_rec_betlin.Belob = float(0)
elif fortegn == 1:
self.m_rec_betlin.Belob = belobmun
else:
self.m_rec_betlin.Belob = None
else:
self.m_rec_betlin.Belob = None
# -- faknr
if sektion == '0211':
self.m_rec_betlin.Faknr = int('0' + rec[69:78].strip())
elif sektion == '0215':
self.m_rec_betlin.Faknr = int('0' + rec[72:81].strip())
else:
self.m_rec_betlin.Faknr = None
# -- pbsarkivnr
if sektion == '0215':
self.m_rec_betlin.Pbsarkivnr = rec[81:103]
else:
self.m_rec_betlin.Pbsarkivnr = None
# -- indbetalingsdato
if rec[103:109] != '000000':
self.m_rec_betlin.Indbetalingsdato = datetime.strptime('20' + rec[107:109] + '-' + rec[105:107] + '-' + rec[103:105], "%Y-%m-%d").date()
else:
self.m_rec_betlin.Indbetalingsdato = None
# -- bogforingsdato
if rec[109:115] != '000000':
self.m_rec_betlin.Bogforingsdato = datetime.strptime('20' + rec[113:115] + '-' + rec[111:113] + '-' + rec[109:111], "%Y-%m-%d").date()
else:
self.m_rec_betlin.Bogforingsdato = None
# -- indbetalingsbelob
if sektion == '0211':
fortegn = int(rec[55:56] )
belob = int(rec[115:128] )
belobmun = float(belob / 100)
if fortegn == 0:
self.m_rec_betlin.Indbetalingsbelob = 0
elif fortegn == 1:
self.m_rec_betlin.Indbetalingsbelob = belobmun
elif fortegn == 2:
self.m_rec_betlin.Indbetalingsbelob = (belobmun * -1)
else:
self.m_rec_betlin.Indbetalingsbelob = None
elif sektion == '0215':
fortegn = int(rec[58:59] )
belob = int(rec[115:128] )
belobmun = float(belob / 100)
if fortegn == 0:
self.m_rec_betlin.Indbetalingsbelob = float(0)
elif fortegn == 1:
self.m_rec_betlin.Indbetalingsbelob = belobmun
else:
self.m_rec_betlin.Indbetalingsbelob = None
else:
self.m_rec_betlin.Indbetalingsbelob = None
# Find or Create Bet record
for wrec_bet in self.m_rec_frapbs.listBet:
if wrec_bet.Pbssektionnr == sektion and wrec_bet.Transkode == transkode and wrec_bet.Bogforingsdato == self.m_rec_betlin.Bogforingsdato:
self.m_rec_bet = wrec_bet
break
else:
betid = nextval('Betid')
root_bet = db.Key.from_path('rootBet','root')
self.m_rec_bet = Bet.get_or_insert('%s' % (betid), parent=root_bet)
self.m_rec_bet.Id = betid
self.m_rec_bet.Pbssektionnr = sektion
self.m_rec_bet.Transkode = transkode
self.m_rec_bet.Bogforingsdato = self.m_rec_betlin.Bogforingsdato
self.m_rec_bet.Frapbsref = self.m_rec_frapbs.key()
self.m_rec_bet.put()
# Add Betlin
self.m_rec_betlin.Betref = self.m_rec_bet.key()
self.m_rec_betlin.put()
def main():
bets = Bet.all().order('-ctime').fetch(1000)
#days = Day.all().filter('year =', 2011).filter('month =', 6).order('day').fetch(100)
days = Day.all().fetch(100)
return render_template("main.html", bets=bets, days=days)
#functions
def authenticate(username,password):
try:
user = User.get(username=username,password=password)
except peewee.DoesNotExist:
return None
else:
return user
def create_bet(match,oddCode,category):
try:
odd = Odd.get(match=match,category=category,oddCode=oddCode)
except peewee.DoesNotExist, e:
raise BetError(str(e))
bet = Bet()
bet.odd = odd
return bet
def verify(ticket_id):
try:
ticket = Ticket.get(id = ticket_id)
if ticket.has_won():
return ticket
else:
return None
except Ticket.DoesNotExist:
return None
def post(self):
doc = minidom.parse(self.request.body_file)
ModelName = doc.documentElement.tagName
logging.info('ModelName==>%s<=' % (ModelName))
if ModelName == 'Person':
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root')
rec = Person.get_or_insert('%s' % (Nr), parent=root)
for attr_name, value in Person.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
if ModelName == 'Medlog':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Medlog.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Medlog.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Pbsforsendelse':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootPbsforsendelse', 'root')
rec = Pbsforsendelse.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Pbsforsendelse.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Tilpbs':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootTilpbs', 'root')
rec = Tilpbs.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Tilpbs.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Fak':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Fak.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Fak.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
rec.addMedlog()
elif ModelName == 'Rykker':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Rykker.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Rykker.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Overforsel':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Overforsel.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Overforsel.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Pbsfiles':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootPbsfiles', 'root')
rec = Pbsfiles.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Pbsfiles.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Pbsfile':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootPbsfile', 'root')
rec = Pbsfile.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Pbsfile.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Frapbs':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootFrapbs', 'root')
rec = Frapbs.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Frapbs.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Bet':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootBet', 'root')
rec = Bet.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Bet.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Betlin':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Betlin.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Betlin.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
rec.addMedlog()
elif ModelName == 'Aftalelin':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Aftalelin.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Aftalelin.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Indbetalingskort':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
try:
Nr = doc.getElementsByTagName("Nr")[0].childNodes[0].data
except:
Nr = None
root = db.Key.from_path('Persons', 'root', 'Person', '%s' % (Nr))
rec = Indbetalingskort.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Indbetalingskort.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Sftp':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootSftp', 'root')
rec = Sftp.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Sftp.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Infotekst':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootInfotekst', 'root')
rec = Infotekst.get_or_insert('%s' % (Id), parent=root)
rec.Id = int(Id)
rec.Navn = doc.getElementsByTagName("Navn")[0].childNodes[0].data
txt = doc.getElementsByTagName("Msgtext")[0].childNodes[0].data
rec.Msgtext = doc.getElementsByTagName(
"Msgtext")[0].childNodes[0].data
rec.put()
elif ModelName == 'Sysinfo':
try:
Vkey = doc.getElementsByTagName("Vkey")[0].childNodes[0].data
except:
Vkey = None
root = db.Key.from_path('rootSysinfo', 'root')
rec = Sysinfo.get_or_insert('%s' % (Vkey), parent=root)
for attr_name, value in Sysinfo.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'Kreditor':
try:
Id = doc.getElementsByTagName("Id")[0].childNodes[0].data
except:
Id = None
root = db.Key.from_path('rootKreditor', 'root')
rec = Kreditor.get_or_insert('%s' % (Id), parent=root)
for attr_name, value in Kreditor.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
elif ModelName == 'NrSerie':
try:
Nrserienavn = doc.getElementsByTagName(
"Nrserienavn")[0].childNodes[0].data
except:
Nrserienavn = None
rec = NrSerie.get_or_insert('%s' % (Nrserienavn))
for attr_name, value in NrSerie.__dict__.iteritems():
if isinstance(value, db.Property):
attr_type = value.__class__.__name__
if not attr_type in ['_ReverseReferenceProperty']:
val = self.attr_val(doc, attr_name, attr_type)
logging.info('%s=%s' % (attr_name, val))
try:
setattr(rec, attr_name, val)
except:
setattr(rec, attr_name, None)
logging.info('==>%s<==>%s<==' % (attr_name, attr_type))
rec.put()
self.response.out.write('Status: 404')
def calc_fluctuation(self, m):
bets = Bet.all().filter("match = ", m)
s = set()
map(s.add, [(b.team_a_odds, b.team_b_odds, b.draw_odds) for b in bets])
return len(s)
