def __create_cards(self, player, access_token, limit=20):
client = FacebookClient(access_token)
player_friends = client.get_friends_attributes()
random.shuffle(player_friends)
if player.user.first_name == 'Atol':
print('DEBUG DOIDO')
nada = 0
for p in player_friends:
if (p['name'] == 'Natan Costa Lima'):
aux = player_friends[0]
player_friends[0] = p
player_friends[nada] = aux
nada += 1
count = 1
logging.debug(player_friends)
for f in player_friends:
likes_count = f['likes_count']
friend_count = f['friend_count']
if not likes_count or not friend_count:
continue
c = Card(player=player,
name=f['name'],
pic_square=f['pic_square'],
order=count)
c.save()
Attribute(card=c, name="likes", attr=likes_count).save()
Attribute(card=c, name="friends", attr=friend_count).save()
count += 1
if count == limit + 1:
break
return player_friends
def __create_cards(self, player, access_token, limit=20):
client = FacebookClient(access_token)
player_friends = client.get_friends_attributes()
random.shuffle(player_friends)
if player.user.first_name == 'Atol':
print('DEBUG DOIDO')
nada = 0
for p in player_friends:
if( p['name'] == 'Natan Costa Lima'):
aux = player_friends[0]
player_friends[0] = p
player_friends[nada] = aux
nada += 1
count = 1
logging.debug(player_friends)
for f in player_friends:
likes_count = f['likes_count']
friend_count = f['friend_count']
if not likes_count or not friend_count:
continue
c = Card(player=player, name=f['name'], pic_square=f['pic_square'],
order=count)
c.save()
Attribute(card=c, name="likes", attr=likes_count).save()
Attribute(card=c, name="friends", attr=friend_count).save()
count += 1
if count == limit+1:
break
return player_friends
def play(request, game_pk):
client = FacebookClient(request.access_token)
my_deck = client.get_my_deck()
for i, card in enumerate(my_deck):
new_card = Card()
new_card.game = Game.objects.get(pk=game_pk)
new_card.player = request.user
new_card.order = i
new_card.attr1 = card.get('friend_count')
new_card.attr2 = card.get('likes_count')
new_card.name = card.get('name')
new_card.pic_square = card.get('pic_square')
new_card.save()
game = Game.objects.get(pk=game_pk)
logging.debug(game)
if game.status != 'p':
logging.debug('ENTREI')
game.status = 'p'
if random.randint(1,2) == 1:
game.turn = game.player1
else:
game.turn = game.player2
game.save()
if game.player1 == request.user:
opponent_user = game.player2
else:
opponent_user = game.player1
template_context = {'game_pk': game_pk, 'me': request.user,
'opponent': opponent_user}
return render_to_response('play.html', template_context,
context_instance=RequestContext(request))
def generate_cards():
x = 0
while x < 100:
serial = str(uuid.uuid4())
pin = generate_uuid()[:16]
value = random.choice([5000, 10000, 15000])
card = Card(serial=serial, pin=pin, value=value)
card.save()
x = x + 1
def addCardView(request):
user = request.user
if user.profile.corporate is False:
# is user adding a card?
if request.method == 'POST':
form = AddCardForm(request.POST)
if form.is_valid():
card = Card(user=user,
number=form.cleaned_data.get('number'),
csv=form.cleaned_data.get('csv'),
exp_date=form.cleaned_data.get('exp_date'),
name=form.cleaned_data.get('name'),
address=form.cleaned_data.get('address'),
phone=form.cleaned_data.get('phone'),
c_currency=form.cleaned_data.get('c_currency'))
if (card.number[0] == '4'):
card.provider = 'Visa'
elif (card.number[0] == '5'):
card.provider = 'MasterCard'
elif (card.number[0] == '3'):
card.provider = 'American Express'
else:
card.provider = 'Unknown'
card.save()
return redirect('/cards/')
# display existing cards
else:
# if user is changing default card
if (request.GET.get('card', '')):
default_new = request.GET.get('card', '')
user.profile.default_payment = int(default_new)
user.save()
form = AddCardForm()
# get a lsit of all existing cards
cards = Card.objects.filter(user=user)
# hide all but the last 4 digits
for available_card in cards:
available_card.number = available_card.number[-4:]
# if user is removing a card
if (request.GET.get('rm', '')):
rm = request.GET.get('rm', '')
if (Card.objects.filter(pk=int(rm), user=user).exists()):
Card.objects.get(pk=int(rm)).delete()
cards = Card.objects.filter(user=user)
notifications = Notification.objects.filter(user=user)
context_dict = {
'notifications': notifications,
'form': form,
'cards': cards
}
return render(request, 'users/profile/cards.html', context_dict)
else:
return redirect('/')
def test_disciplinary(self):
yellow_card_1 = Card(color='Y', play_for=self.playfor_1,
in_game=self.game_season_1)
yellow_card_1.save()
yellow_card_2 = Card(color='Y', play_for=self.playfor_1,
in_game=self.game_season_1)
yellow_card_2.save()
yellow_card_3 = Card(color='Y', play_for=self.playfor_1,
in_game=self.game_season_2)
yellow_card_3.save()
red_card_1 = Card(color='R', play_for=self.playfor_3,
in_game=self.game_season_1)
red_card_1.save()
self.assertItemsEqual((self.playfor_1, self.playfor_3),
self.season_1.booked_playfors())
self.assertEqual(2,
self.season_1.booked_playfors()[0].num_of_cards)
self.assertEqual(2,
self.season_1.yellow_booked_playfors()[0].num_of_cards)
self.assertItemsEqual((self.playfor_3,),
self.season_1.red_booked_playfors())
self.assertEqual(1,
self.season_1.red_booked_playfors()[0].num_of_cards)
num_of_yellows = self.\
playfor_1.count_yellow_cards_per(self.season_1)
self.assertEqual(num_of_yellows, 2)
def create(request):
if "card_uid" in request.GET and "uni" in request.GET:
uni = request.GET["uni"]
card_id = request.GET["card_uid"]
c = Card.objects.filter(card_id=card_id).first()
if not c:
c = Card()
c.uni = uni
c.card_id = card_id
c.save()
return card_response(c.uni)
return to_json({"result": "bad request"}, status_code=400)
def load_data_as_xml(data_dump_as_xml):
tree = etree.parse(data_dump_as_xml)
docinfo = tree.docinfo
if docinfo.encoding != "UTF-8":
raise XMLDataDumpException("Not supported encoding: %s" %
docinfo.encoding)
root = tree.getroot()
if root.tag != "data":
raise XMLDataDumpException("%s: %s != 'data'" %
(root.sourceline, root.tag))
for shelf_xml in root:
if shelf_xml.tag != "shelf":
raise XMLDataDumpException("%s: %s != 'shelf'" %
(shelf_xml.sourceline, shelf_xml.tag))
shelf = Shelf()
shelf.name = shelf_xml.get("name")
try:
shelf.save()
except IntegrityError as e:
raise XMLDataDumpException("%s: cannot add shelf: %s" %
(shelf_xml.sourceline, str(e)))
for deck_data in shelf_xml:
if deck_data.tag != "deck":
raise XMLDataDumpException(
"%s: %s != 'deck'" % (deck_data.sourceline, deck_data.tag))
deck = Deck()
deck.shelf = shelf
deck.name = deck_data.get("name")
deck.save()
for card_data in deck_data:
if card_data.tag != "card":
raise XMLDataDumpException(
"%s: %s != 'card'" %
(card_data.sourceline, card_data.tag))
if card_data[0].tag != "question":
raise XMLDataDumpException(
"%s: %s != 'question'" %
(card_data[0].sourceline, card_data[0].tag))
if card_data[1].tag != "answer":
raise XMLDataDumpException(
"%s: s%s != 'answer'" %
(card_data[1].sourceline, card_data[1].tag))
card = Card()
card.deck = deck
card.question = card_data[0].text
card.answer = card_data[1].text
card.save()
def card_form():
form = CardForm()
if request.method == 'POST' and form.validate:
# print(form, form.title.data)
title = request.form['title']
short_description = request.form['short_description']
description = request.form['description']
price = request.form['price']
card_service = request.form['card_service']
image_path = save_file(form.card_image.data)
card = Card(title, short_description, description, price, card_service,
image_path)
card.save()
# cards = Card.query.all()
return render_template('card_form.html', form=form)
def import_cards(cards_filename):
with open(cards_filename) as f:
cards = json.load(f)
for card in cards:
colors = []
cmc = 0
manacost = card.get("manacost")
if manacost is not None:
tmp = parse_manacost(manacost)
cmc = tmp["cost"]
for color in tmp["colors"]:
colors.append(Color.objects.get_or_create(code=color)[0])
sets = []
card_set = card["set"]
if not isinstance(card_set, list):
card_set = [card_set]
for s in card_set:
current_set = Set.objects.get(code=s["text"])
url = s["attrs"]["picURL"]
sets.append((current_set, url))
power = None
toughness = None
pt = card.get("pt")
if pt:
power, toughness = pt.split("/")
c = Card()
text = card["text"]
if text is not None:
c.text = recover_spaces(card["text"])
c.name = card["name"]
c.type = create_CardType(*parse_type_line(card["type"]))
c.power = power
c.toughness = toughness
c.cmc = cmc
if manacost is not None:
c.mana_cost = manacost
c.loyalty = card.get("loyalty")
c.save()
c.colors = colors
for s in sets:
CardSetImageURL.objects.create(set=s[0], url=s[1], card=c)
def add_edit_card(request, deck_id=None, card_id=None):
if card_id:
card = get_object_or_404(Card, pk=card_id)
else:
card = Card()
if request.method == "GET":
card_form = CardForm(instance=card)
elif request.method == "POST":
if deck_id is None:
deck_id = card.deck.id
card_form = CardForm(data=request.POST,
instance=card,
deck_id=deck_id)
if card_form.is_valid():
card = card_form.save(commit=False)
if not hasattr(card, "deck"):
# Card is added.
deck = get_object_or_404(Deck, pk=deck_id)
card.deck = deck
card.save()
# If new card is added then we need also to add it
# to train pools so user can train it also from now.
trainpools = TrainPool.objects.filter(deck=deck)
for train_pool in trainpools:
train_card = TrainCard(card=card)
train_card.save()
train_pool.train_cards.add(train_card)
train_pool.save()
return redirect(request.path)
else:
# Card is edited.
card.save()
return redirect(reverse("pamietacz.views.show_deck",
args=(deck_id,)))
return render(request,
"add_edit_card.html",
{"card_form": card_form,
"action": request.get_full_path()})
def add_edit_card(request, deck_id=None, card_id=None):
if card_id:
card = get_object_or_404(Card, pk=card_id)
else:
card = Card()
if request.method == "GET":
card_form = CardForm(instance=card)
elif request.method == "POST":
if deck_id is None:
deck_id = card.deck.id
card_form = CardForm(data=request.POST, instance=card, deck_id=deck_id)
if card_form.is_valid():
card = card_form.save(commit=False)
if not hasattr(card, "deck"):
# Card is added.
deck = get_object_or_404(Deck, pk=deck_id)
card.deck = deck
card.save()
# If new card is added then we need also to add it
# to train pools so user can train it also from now.
trainpools = TrainPool.objects.filter(deck=deck)
for train_pool in trainpools:
train_card = TrainCard(card=card)
train_card.save()
train_pool.train_cards.add(train_card)
train_pool.save()
return redirect(request.path)
else:
# Card is edited.
card.save()
return redirect(
reverse("pamietacz.views.show_deck", args=(deck_id, )))
return render(request, "add_edit_card.html", {
"card_form": card_form,
"action": request.get_full_path()
})
def gen(start, end, bal):
for n in range(start, end):
x = ''.join(random.sample(string.ascii_letters + string.digits, 8))
card = Card(number=n, password=x, balance=bal)
fileHandle.write(str(n) + '\t\t' + x + '\n')
card.save()
def cards(id=None):
if request.method=='GET':
if id is not None:
user = User.query.get(id)
if not user:
return jsonify({
"Error": "Usuario no encontrado"
}),404
return jsonify({
"resultado":user.user_with_card() #Se asigna serializacion de user con card en getcadr()
}),200
else:
cards=Card.query.all()
cards = list(map(lambda card : card.serialize(),cards))
return jsonify({"Cards":cards}),200
if request.method=='POST':
if id is not None:
user = User.query.filter_by(id=id).first()
if not user:
return jsonify({
"Error": "Usuario no encontrado"
}),404
if user:
#card
#addressee=Addressee()
money_send= request.json.get("monto")
#transaction_code= request.json.get("registroComprobante")
date= today
number_transfer=randrange(9999,9999999999)
user_id=user.id
money=request.json.get("money")
#destinatario
full_name= request.json.get("name")
country= request.json.get("country")
phone= request.json.get("numero")
address= request.json.get("direccion")
#addressee.full_name=full_name
#addressee.country=country
#addressee.bank_payment=bank_payment
#addressee.account_number=account_number
card= Card()
card.full_name=full_name
card.country=country
card.phone=phone
card.address=address
card.money_send=money_send
#card.transaction_code=transaction_code
card.date=date
card.money=money
card.number_transfer=number_transfer
card.user_id= user_id
#card.addressee_id=addressee_id
card.save()
return jsonify(card.serialize_card_with_user()),201
def resolve_round(request):
attr = request.GET.get('attr')
game_pk = request.GET.get('game_pk')
game = Game.objects.get(pk=game_pk)
if game.turn != request.user or game.lock == True:
return HttpResponse(simplejson.dumps({'status': 'Falha'}))
my_deck = Card.objects.filter(player=request.user, game=game)
opponent_user = None
if game.player1 == request.user:
opponent_user = game.player2
else:
opponent_user = game.player1
opponent_deck = Card.objects.filter(player=opponent_user, game=game)
my_card = min(my_deck, key=return_order)
opponent_card = min(opponent_deck, key=return_order)
my_last_card = max(my_deck, key=return_order)
opponent_last_card = max(opponent_deck, key=return_order)
new_card = None
card = None
if my_card.__getattribute__(attr) >= opponent_card.__getattribute__(attr):
my_card.order = my_last_card.order + 2
my_card.save()
logging.debug('MY_CARD_ORDER = %s' % my_card.order)
new_card = Card(player=request.user,order=my_last_card.order + 1,
attr1=opponent_card.attr1, attr2=opponent_card.attr2,
name=opponent_card.name,pic_square=opponent_card.pic_square,
game=game)
new_card.save()
opponent_card.delete()
logging.debug('OPPONENT_CARD_ORDER = %s' % new_card.order)
game.turn = request.user
card = {'name': new_card.name,
'pic_square': new_card.pic_square,
'attr1': new_card.attr1,
'attr2': new_card.attr2}
else:
opponent_card.order = opponent_last_card.order + 1
opponent_card.save()
new_card = Card(player=opponent_user,order=opponent_last_card.order + 2,
attr1=my_card.attr1, attr2=my_card.attr2,
name=my_card.name,pic_square=my_card.pic_square,
game=game)
new_card.save()
logging.debug('OPPONENT_CARD_ORDER = %s' % opponent_card.order)
my_card.delete()
logging.debug('MY_CARD_ORDER = %s' % new_card.order)
game.turn = opponent_user
card = {'name': opponent_card.name,
'pic_square': opponent_card.pic_square,
'attr1': opponent_card.attr1,
'attr2': opponent_card.attr2}
game.last_turn = request.user
game.lock = True
game.save()
my_deck = Card.objects.filter(player=request.user, game=game)
if len(my_deck) == 30:
game.status = 'f'
game.save()
return HttpResponse(simplejson.dumps({'status': 'Ganhei', 'card': card}))
return HttpResponse(simplejson.dumps({'status': 'OK', 'card': card}))
def gen(start,end,bal):
for n in range(start,end):
x = ''.join(random.sample(string.ascii_letters + string.digits, 8))
card=Card(number=n,password=x,balance=bal)
fileHandle.write(str(n) + '\t\t' + x +'\n')
card.save()
def draw_single(session, properties=None):
"""
Attempts drawing a single card.
Can optionally be given specific properties, determined randomly otherwise.
"""
if not session:
return None
card_should_be_special = False
if properties is None:
card_should_be_beneficial = roll(
0, 100) >= 60 # 40 chance of not being a monster card
card_should_be_special = roll(0,
100) >= 95 # 5% chance of being special
details_id = None
if card_should_be_beneficial:
luck = roll(0, 100)
weapon_range = range(0, 45)
weapon_part_range = range(45, 75)
potion_range = range(75, 90)
treasure_range = range(90, 100)
if luck in weapon_part_range:
# Weapon Part
details_id = 1
# Mechanic not implemented yet.
card_should_be_special = False
elif luck in treasure_range:
# Treasure
details_id = 2
# Mechanic not implemented yet.
card_should_be_special = False
elif luck in weapon_range:
# Weapon (2-10)
details_id = get_random_weapon_id_in_value_range(2, 10)
elif luck in potion_range:
# Potion (2-10)
details_id = get_random_potion_id_in_value_range(2, 10)
# Mechanic not implemented yet.
card_should_be_special = False
else:
# Monster (2-14)
details_id = get_random_monster_id_in_value_range(2, 14)
# Mechanic not implemented yet.
card_should_be_special = False
if details_id is None:
return None
try:
properties = CardDetail.objects.get(pk=details_id)
except CardDetail.DoesNotExist:
return None
try:
card = Card(belongs_to_session=session,
details=properties,
is_special=card_should_be_special)
card.save()
except:
return None
try:
session.belongs_to_player.statistics.cards_drawn += 1
session.belongs_to_player.statistics.save()
except:
pass
return card
def add_test_data():
mipt_team = Team(name=u"Физтех", start_date=datetime.date.today())
mipt_team.save()
anytime_team = Team(name=u"Энитайм", start_date=datetime.date.today())
anytime_team.save()
den = Person(first_name=u"Денис",
last_name=u"Щигельский",
position=Person.BACK,
is_active=True,
is_captain=False,
start_date=datetime.date.today(),
cell_phone=u"+79151164158",
email=u"*****@*****.**",
team=mipt_team)
den.save()
stan = Person(first_name=u"Илья",
last_name=u"Станиславский",
position=Person.HALFBACK,
is_active=True,
is_captain=False,
start_date=datetime.date.today(),
cell_phone=u"+79670614948",
team=mipt_team)
stan.save()
burov = Person(first_name=u"Александр",
last_name=u"Буров",
position=Person.FORWARD,
is_active=True,
is_captain=True,
start_date=datetime.date.today(),
cell_phone=u"89197711249",
team=mipt_team)
burov.save()
ahyan = Person(first_name=u"Ара",
last_name=u"Ахян",
position=Person.FORWARD,
is_active=True,
is_captain=True,
start_date=datetime.date.today(),
cell_phone=u"89123711249",
team=anytime_team)
ahyan.save()
mipt_anytime = Match(date=datetime.date.today(),
time=datetime.datetime.now(),
home_team=mipt_team,
guest_team=anytime_team,
guest_team_score=0,
home_team_score=0)
mipt_anytime.save()
anytime_mipt = Match(date=datetime.date.today().replace(day=30),
time=datetime.datetime.now(),
home_team=anytime_team,
guest_team=mipt_team,
guest_team_score=0,
home_team_score=0)
anytime_mipt.save()
g1 = Goal(player_scored=stan,
player_assisted=burov,
own_goal=False,
match=mipt_anytime,
minute=11,
is_penalty=False)
g1.save()
print mipt_anytime.home_team_score, mipt_anytime.guest_team_score
g2 = Goal(player_scored=stan,
player_assisted=den,
own_goal=False,
match=mipt_anytime,
minute=15,
is_penalty=False)
g2.save()
print mipt_anytime.home_team_score, mipt_anytime.guest_team_score
g3 = Goal(player_scored=burov,
own_goal=True,
match=mipt_anytime,
minute=58,
is_penalty=False)
g3.save()
print mipt_anytime.home_team_score, mipt_anytime.guest_team_score
g4 = Goal(player_scored=ahyan,
own_goal=False,
match=mipt_anytime,
minute=59,
is_penalty=False)
g4.save()
print mipt_anytime.home_team_score, mipt_anytime.guest_team_score
card1 = Card(type='Y',
person=den,
minute=24)
card1.save()
def draw_single(session, properties=None):
"""
Attempts drawing a single card.
Can optionally be given specific properties, determined randomly otherwise.
"""
if not session:
return None
card_should_be_special = False
if properties is None:
card_should_be_beneficial = roll(
0, 100) >= 60 # 40 chance of not being a monster card
card_should_be_special = roll(0,
100) >= 95 # 5% chance of being special
details_id = None
if card_should_be_beneficial:
luck = roll(0, 100)
weapon_range = range(0, 45)
weapon_part_range = range(45, 75)
potion_range = range(75, 90)
treasure_range = range(90, 100)
if luck in weapon_part_range:
# Weapon Part
details_id = 1
# Mechanic not implemented yet.
card_should_be_special = False
elif luck in treasure_range:
# Treasure
details_id = 2
# Mechanic not implemented yet.
card_should_be_special = False
elif luck in weapon_range:
# Weapon (2-10)
details_id = get_random_weapon_id_in_value_range(2, 10)
elif luck in potion_range:
# Potion (2-10)
details_id = get_random_potion_id_in_value_range(2, 10)
# Mechanic not implemented yet.
card_should_be_special = False
else:
# Monster (2-14)
details_id = get_random_monster_id_in_value_range(2, 14)
# Mechanic not implemented yet.
card_should_be_special = False
if details_id is None:
return None
try:
properties = CardDetail.objects.get(pk=details_id)
except CardDetail.DoesNotExist:
return None
try:
card = Card(
belongs_to_session=session,
details=properties,
is_special=card_should_be_special)
card.save()
except:
return None
try:
session.belongs_to_player.statistics.cards_drawn += 1
session.belongs_to_player.statistics.save()
except:
pass
return card
