Esempio n. 1
0
    def test_card_all_one_cards(self):
        self.assertEquals(Card.objects.get_queryset().all().count(), 0)

        # add expansion set
        es = ExpansionSet(name="Alpha", abbr="aaa")
        es.save()

        # add a rarity
        rc = Rarity(id='c', rarity='Common', sortorder=1)
        rc.save()

        # add a card
        pc = PhysicalCard()
        pc.save()
        bc = BaseCard()
        bc.physicalcard = pc

        bc.name = 'Test Name'
        bc.clean()
        bc.save()
        self.assertEquals(bc.physicalcard.layout, PhysicalCard.NORMAL)
        c = Card(
            basecard=bc,
            rarity=rc,
            expansionset=es,
            multiverseid=100,
            card_number='99')
        c.save()

        self.assertEquals(Card.objects.get_queryset().all().count(), 1)
Esempio n. 2
0
    def _load_cards(self, eras, mythologies, tags):

        path = pathlib.Path('cards/all_data/cards/').glob('*.yaml')

        for file in path:
            with open(file) as f:
                card = yaml.safe_load(f)
                c = Card(
                    name=card['name'],
                    card_type=card['card_type'],
                    cost=card['cost'],
                    strength=card['strength'],
                    max_pow=card['max_pow'],
                    init_pow=card['init_pow'],
                    mythology=mythologies[card['mythology']] if card['mythology'] else None,
                    passive_effect=card['passive_effect'],
                    quote=card['quote'],
                    image=card['image']
                )

                c.save()

                for era in card['eras']:
                    c.eras.add(eras[era])

                if card['tags']:
                    for tag in card['tags']:
                        c.tags.add(tags[tag])

                if card['abilities']:
                    for ab in card['abilities']:
                        for p, a in ab.items():
                            ability = Ability.objects.create(name=a, phase=p)
                            c.abilities.add(ability)
Esempio n. 3
0
    def post(self, request, *args, **kwargs):
        c = Card()
        c.name = request.data.get('name')
        c.spell_type = request.data.get('spell_type')
        c.expansion = request.data.get('expansion')
        c.is_legendary = request.data.get('is_legendary') is 'true'
        c.card_number = request.data.get('card_number')
        c.creature_type = request.data.get('creature_type')
        c.abilities = request.data.get('abilities')
        c.text = request.data.get('text')
        c.flavor_text = request.data.get('flavor_text')
        c.power = request.data.get('power')
        c.defense = request.data.get('defense')
        c.loyalty = request.data.get('loyalty')
        c.artist = request.data.get('artist')
        c.save()
        c.image = request.data.get('file')
        for k, v in request.data.items():
            if k.startswith('mana_'):

                m = Mana.objects.get(name=k[5:])
                mfc = ManaForCard()
                mfc.mana = m
                mfc.card = c
                mfc.quantity = v
                mfc.save()
        c.save()
        return Response(self.serializer_class(c).data)
Esempio n. 4
0
def upload_card_set(request):
    if request.method == 'POST':
        form = UploadCardSetForm(request.POST, request.FILES)
        if form.is_valid():
            # Read cards file
            try:
                cards = Mnemosyne2Cards.read(request.FILES['file'])
            except Exception:
                # FIXME be more specific about what to catch
                cards = None

            #print >>sys.stderr, cards
            if cards:
                # Create new card set
                card_set = CardSet(name=form.cleaned_data['name'])
                card_set.save()

                # Create cards
                for question, answer in cards:
                    card = Card(card_set=card_set, question=question, answer=answer)
                    card.save()

        # TODO: provide feedback for invalid uploads
    else:
        form = UploadCardSetForm()
    return render_to_response('upload.html',
            {'form': form},
            context_instance=RequestContext(request))
Esempio n. 5
0
def createCard(request):
    if request.user.is_authenticated():
        if request.method == 'POST':
            try:
                formDict = json.loads(request.body, encoding='latin1')
            except ValueError as e:
                print e
                return HttpResponse(status=500)
            try:
                values = parseCreateCardFormData(formDict)
                card = Card(name=values[0],
                            value=values[1],
                            cardIcon=values[2])
                card.save()
                cardUser = CardUser(user=request.user,
                                    card=card,
                                    expiry_date=values[3])
                cardUser.save()
            except Exception as e:
                print e
                return HttpResponse(status=500)
            return HttpResponse(card.id)
        else:
            return HttpResponse(status=400)

    return HttpResponse(status=401)
Esempio n. 6
0
    def update_cards(self) -> bool:
        """
                Updates existing Cards with any changes
                returns: True if there were no errors, otherwise False
                """
        self.logger.info("Updating %s cards", UpdateCard.objects.count())
        card_to_update: UpdateCard
        for card_to_update in UpdateCard.objects.all():
            if card_to_update.update_mode == UpdateMode.CREATE:
                card = Card(
                    scryfall_oracle_id=card_to_update.scryfall_oracle_id,
                    name=card_to_update.name,
                )
            else:
                card = Card.objects.get(
                    scryfall_oracle_id=card_to_update.scryfall_oracle_id)

            for field, value in card_to_update.field_data.items():
                if card_to_update.update_mode == UpdateMode.UPDATE:
                    value = value["to"]

                if hasattr(card, field):
                    setattr(card, field, value)
                else:
                    raise NotImplementedError(
                        f"Cannot update unrecognised field Card.{field}")
            card.save()
        return True
Esempio n. 7
0
def create_test_card(fields: Optional[Dict[str, Any]] = None) -> Card:
    """
    Creates a test card with fields from the given dict
    :param fields: The fields to populate
    :return: A card object
    """
    card = Card()
    card.scryfall_oracle_id = uuid.uuid4()
    card.name = uuid.uuid1()
    card.cmc = 0
    card.num_power = 0
    card.num_toughness = 0
    card.num_loyalty = 0
    card.colour_flags = 0
    card.colour_identity_flags = 0
    card.colour_count = 0
    card.colour_identity_count = 0
    card.colour_sort_key = 0
    card.colour_weight = 0
    card.layout = "normal"
    card.is_reserved = False
    card.is_token = False
    card.converted_mana_cost = 0

    for key, value in (fields or {}).items():
        assert hasattr(card, key)
        setattr(card, key, value)

    card.full_clean()
    card.save()
    return card
Esempio n. 8
0
 def test_votes_use_elo(self):
     bad_card = Card(name='Baddie',elo=1000,votes=1000)
     good_card = Card(name='Goodie',elo=1900,votes=1000)
     good_card.save()
     bad_card.save()
     response = self.client.post('/vote/', {'voted_for':'Goodie', 'voted_against':'Baddie'})
     return self.assertEqual(Card.objects.get(name='Goodie').elo,1902) #minimum elo gain
Esempio n. 9
0
def test_cards_get_random_words(admin):
    """
    Test the select_random_words method
    """
    with pytest.raises(ValueError) as error:
        Card.objects.select_random_words()
        assert error == 'the user and words fields are empty at the same time'
    words = Card.objects.select_random_words(admin)
    assert len(words) == 2

    random_words = Card.objects.get_random_words(admin)
    words = Card.objects.select_random_words(words=random_words,
                                             additional='additional')
    assert len(words) == 2

    for i in range(10):
        card = Card()
        card.word = 'word' + str(i)
        card.complete = 122
        card.created_by = admin
        card.deck_id = 1
        card.save()

    words = Card.objects.select_random_words(admin, additional='additional')
    words_next = Card.objects.select_random_words(admin,
                                                  additional='additional')
    assert len(words) == 4
    assert words != words_next

    assert 'additional' in words
Esempio n. 10
0
    def update_card(self, staged_card: StagedCard) -> Card:
        """
        Updates or creates the Card object for the given StagedCard
        :param staged_card: The staging information for this card
        :return: The updated or created Card
        """
        try:
            if staged_card.is_token:
                card = Card.objects.get(name=staged_card.get_name(),
                                        scryfall_oracle_id=staged_card.get_scryfall_oracle_id(),
                                        is_token=True,
                                        side=staged_card.get_side())
            else:
                card = Card.objects.get(name=staged_card.get_name(), is_token=False)
                if not self.force_update and staged_card.get_name() in self.updated_cards:
                    logger.info('%s has already been updated', card)
                    self.increment_ignores('Card')
                    return card

            logger.info('Updating existing card %s', card)
            self.increment_updated('Card')
        except Card.DoesNotExist:
            card = Card(name=staged_card.get_name())
            logger.info('Creating new card %s', card)
            self.increment_created('Card')

        self.updated_cards.append(staged_card.get_name())

        card.cost = staged_card.get_mana_cost()
        card.cmc = staged_card.get_cmc()
        card.colour_flags = staged_card.get_colour()
        card.colour_identity_flags = staged_card.get_colour_identity()
        card.colour_count = staged_card.get_colour_count()
        card.colour_sort_key = staged_card.get_colour_sort_key()
        card.colour_weight = staged_card.get_colour_weight()

        card.power = staged_card.get_power()
        card.toughness = staged_card.get_toughness()
        card.num_power = staged_card.get_num_power()
        card.num_toughness = staged_card.get_num_toughness()
        card.loyalty = staged_card.get_loyalty()
        card.num_loyalty = staged_card.get_num_loyalty()

        card.type = staged_card.get_types()
        card.subtype = staged_card.get_subtypes()
        card.original_type = staged_card.get_original_type()

        card.rules_text = staged_card.get_rules_text()
        card.original_text = staged_card.get_original_text()
        card.layout = staged_card.get_layout()
        card.side = staged_card.get_side()
        card.scryfall_oracle_id = staged_card.get_scryfall_oracle_id()
        card.is_reserved = staged_card.is_reserved()
        card.is_token = staged_card.is_token

        card.full_clean()
        card.save()
        return card
Esempio n. 11
0
def test_cards_default_deck(admin):
    """
    Should set the default deck for user
    """
    card = Card()
    card.word = 'word'
    card.created_by = admin
    card.save()

    assert card.deck_id == 1
Esempio n. 12
0
 def form_valid(self, form):
     import_text = form.cleaned_data.pop("import_text")
     form.cleaned_data["owner"] = self.request.user
     course = Course(**form.cleaned_data)
     course.save()
     if import_text:
         for (term, definition) in import_text:
             card = Card(term=term, definition=definition, course=course)
             card.save()
     return super().form_valid(form)
Esempio n. 13
0
 def create(self, validated_data):
     new_position = Card.objects.filter(
         list_id=validated_data['list_id'].id).count() + 1
     card = Card(name=validated_data['name'],
                 list_id=validated_data['list_id'],
                 description=validated_data['description'],
                 owner=validated_data['owner'],
                 expiration_date=validated_data['expiration_date'],
                 position=new_position)
     card.save()
     return card
Esempio n. 14
0
def index(request):
    cards = Card.objects.all().order_by('name', 'edition')
    if request.method == 'POST':
        form = CardForm(request.POST)
        if form.is_valid():
            edition = Edition.objects.get(set_id=form.cleaned_data['edition'])

            foil = False
            if (('foil' in form.cleaned_data and
                 form.cleaned_data['foil'] == 'true')):
                foil = True

            try:
                card = Card.objects.get(
                    name=form.cleaned_data['name'],
                    foil=foil,
                    edition=edition,
                    condition=form.cleaned_data['condition'])

                card.quantity += int(form.cleaned_data['quantity'])
                card.save()
            except Card.DoesNotExist:
                card = Card(
                    name=form.cleaned_data['name'],
                    edition=edition,
                    foil=foil,
                    condition=form.cleaned_data['condition'],
                    quantity=form.cleaned_data['quantity'])
                card.save()

                url = ('https://api.deckbrew.com/mtg/cards/%s' %
                       slugify(card.name))

                response = requests.get(url)
                editions = response.json()['editions']
                for edition in editions:
                    if ((edition['set_id'] == card.edition.set_id and
                         'price' in edition)):
                        card.multiverse_id = edition['multiverse_id']
                        card.rarity = edition['rarity'][0].upper()
                        card.price_low = edition['price']['low'] / 100.0
                        card.price_med = edition['price']['median'] / 100.0
                        card.price_high = edition['price']['high'] / 100.0

                        card.save()

    form = CardForm()

    context = Context({
        'card_list': cards,
        'form': form
    })

    return render(request, 'index.html', context)
def push_from_json(json_file_path):
    with open(json_file_path, 'r') as f:
        cards = json.load(f)
    counter = 0
    size = len(cards)
    for card in cards:
        new_card = Card(name=card['card_name'],
                        local_path=card['card_image_url'].split('info')[1])
        new_card.save()
        counter += 1
        print('{}/{} card pushed'.format(counter, size))
Esempio n. 16
0
 def handle(self, *args, **options):
     csv_file = options['csv_file']
     with open(csv_file, encoding="latin-1") as datafile:
         reader = csv.DictReader(datafile)
         for row in reader:
             row['uuid'] = uuid.uuid4()
             card = Card()
             for field, data in row.items():
                 if '' != data:  # only ingest fields with data
                     setattr(card, field, data)
             card.save()
Esempio n. 17
0
def cardsForAddress(request, address):
    if request.method == "GET":
        cards = Card.objects.filter(owner=address)
        cards = list(map(lambda card: "{\"name\": \"" + card.template.name + "\", \"cardId\":" + str(card.template.cardId) + ",\"address\": \"" + card.address + "\"}", cards))
        cards = '[' + ','.join(cards) + ']'
        return HttpResponse("{\"cards\": " + str(cards) +"}")
    elif request.method == 'POST':
        body = json.loads(request.body.decode("utf-8"))
        # Check if card has already been submitted
        if Card.objects.filter(id=body['id']).count() != 0:
            return HttpResponse("{message: There already exists a card with this id.}", status=403)
        card = Card(template=CardTemplate.objects.filter(name=body['name']).first(),owner=address, id=body['id'],address=body['address'])
        card.save()
        return HttpResponse("{\"name\": \"" +card.template.name + "\", \"cardId\": " + str(card.template.cardId)  + "}")
Esempio n. 18
0
def test_cards_guess_and_set_category(admin):
    """
    Should guess and set the word category
    """
    card = Card()
    card.word = 'word'
    card.created_by = admin
    card.save()

    assert card.category == 'word'

    card = Card()
    card.word = 'come up with'
    card.created_by = admin
    card.save()

    assert card.category == 'phrasal_verb'

    card = Card()
    card.word = 'get over'
    card.created_by = admin
    card.save()

    assert card.category == 'phrasal_verb'

    card = Card()
    card.word = 'to put it mildly'
    card.created_by = admin
    card.save()

    assert card.category == 'phrase'
Esempio n. 19
0
def test_cards_limit_complete_deck(admin):
    """
    The card complete field can't be less then zero
    """
    card = Card()
    card.word = 'word'
    card.complete = 122
    card.created_by = admin
    card.deck_id = 1
    card.save()

    assert card.complete == 100

    card.complete = -23
    card.save()
    assert card.complete == 0
Esempio n. 20
0
def add_new_card(request, card_uid):
    card = Card(tag_uid=card_uid)
    encKeyA = request.POST["keyA"]
    encKeyB = request.POST["keyB"]

    card.keyA = encKeyA
    card.keyB = encKeyB
    card.save()

    # Log everything!
    event_text = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    event_text += " [Door.Back]"
    event_text += " New Card"
    event_text += " (" + card_uid + ")"
    event_text += " Card Added"

    return render_to_response("cards/success.txt")
Esempio n. 21
0
def createCard(request):
    if request.user.is_authenticated():
        if request.method == 'POST': 
            try:
                formDict = json.loads(request.body, encoding = 'latin1')
            except ValueError as e:
                print e
                return HttpResponse(status=500)
            try:
                values = parseCreateCardFormData(formDict)             
                card = Card(name = values[0], value = values[1], cardIcon = values[2])
                card.save()
                cardUser = CardUser(user = request.user, card = card, expiry_date = values[3])
                cardUser.save()
            except Exception as e:
                print e
                return HttpResponse(status=500)    
            return HttpResponse(card.id)
        else:
            return HttpResponse(status=400)
    
    return HttpResponse(status=401)
Esempio n. 22
0
def create_test_card(fields: dict) -> Card:
    """
    Creates a test card with fields from the given dict
    :param fields: The fields to populate
    :return: A card object
    """
    card = Card()
    card.name = 'undefined'
    card.cmc = 0
    card.num_power = 0
    card.num_toughness = 0
    card.num_loyalty = 0
    card.colour_count = 0
    card.colour_sort_key = 0
    card.colour_weight = 0
    card.is_reserved = False

    for key, value in fields.items():
        card.__dict__[key] = value

    card.save()
    return card
Esempio n. 23
0
    def handle(self, *args, **options):
        try:
            file = io.open('cardlist.txt', 'rt')
            errors = io.open('failed.txt', 'w')

            booster = None
            count = 0
            fail_count = 0

            for line in file:
                if line.strip() == '':
                    continue
                if line.startswith('###'):
                    booster_name = line.strip('# \n')
                    print booster_name
                    booster = Booster.objects.get(name=booster_name)
                    continue

                count += 1

                try:
                    response = requests.get('http://yugiohprices.com/api/card_data/' + line.strip())
                    json = response.json()
                except Exception, e:
                    bugsnag.notify(e, context='CardImport', meta_data={ 'card': line, 'booster_name': booster_name, 'response': response.text })
                    json = None

                card = Card(name=line.strip())

                if json and json['status'] == 'success':
                    card.description = json['data']['text']

                    if json['data']['card_type'] == 'monster':
                        card.attack = json['data']['atk']
                        card.defense = json['data']['def']
                        card.attribute = json['data']['family'].lower()
                        card.level = json['data']['level']
                        card.save()

                        types = []
                        for t in json['data']['type'].split('/'):
                            ct = CardType.objects.get(name=t.strip())
                            types.append(ct.id)
                        card.card_types = types
                    else:
                        card.effect_type = ('{} {}'.format(json['data']['property'], json['data']['card_type'])).lower()
                else:
                    errors.write(line)
                    errors.flush()
                    fail_count += 1

                card.save()
                card.boosters = [ booster.id ]
                card.save()

                print '{} - {} ({})'.format(booster.name, line.strip(), str(count))
        except Exception, e:
            bugsnag.notify(e, context='CardImport', meta_data={ 'card': line, 'booster_name': booster_name, 'response': response.text })
Esempio n. 24
0
def rest_new_card(request):
    response = {}
    if request.method == 'PUT':
        user = UserCustom.objects.get(user_id__exact=request.user.pk)
        card_new_data = json.loads(request.body.decode())

        card = Card()
        card.org = user.org
        card.reg_date = datetime.now()
        card.changes_date = datetime.now()
        card.holder_name = card_new_data['holder_name']
        card.code = card_new_data['code']
        card.holder_phone = card_new_data['holder_phone']
        card.sex = card_new_data['sex']
        card.type = card_new_data['type']
        try:
            card.save()
            response['status'] = 'success'
            response['message'] = 'Новая карта успешно заведена!'
            return JsonResponse(response, safe=False)
        except IntegrityError as err:
            response['status'] = 'error'
            response['message'] = 'Карта с таким кодом уже существует!'
            return JsonResponse(response, safe=False)
Esempio n. 25
0
 def test_votes_use_certainty(self):
     new_card = Card(name='Cobblebrute',elo='1000',votes=10)
     new_card.save()
     new_card = Card(name='Homicidal Seclusion',elo='1000',votes=0)
     new_card.save()
     new_card = Card(name='Rakdos Guildgate',elo='1000',votes=0)
     new_card.save()
     new_card = Card(name='Life from the Loam',elo='1000',votes=0)
     new_card.save()
     
     response = self.client.post('/vote/', {'voted_for':'Cobblebrute', 'voted_against':'Homicidal Seclusion'})
     response = self.client.post('/vote/', {'voted_for':'Rakdos Guildgate', 'voted_against':'Life from the Loam'})
     cobblebrute = Card.objects.get(name='Cobblebrute')
     rakdos_guildgate = Card.objects.get(name='Rakdos Guildgate')
     homicidal_seclusion = Card.objects.get(name='Homicidal Seclusion')
     life_from_the_loam = Card.objects.get(name='Life from the Loam')
     
     if (rakdos_guildgate.elo > cobblebrute.elo and cobblebrute.elo > 1000 and life_from_the_loam.elo == homicidal_seclusion.elo):
         pass
     else:
         self.fail("ELOs not moving properly: " + str(rakdos.elo) + " " + str(cobblebrute.elo)
                   + " " + str(life_from_the_loam.elo) + " " + str(homicidal_seclusion.elo))
Esempio n. 26
0
def create_standard_cards():
    # creating abilities
    # tap for mana
    tap_ability = Ability(cost='t', benefit='m1g')
    tap_ability.save()

    # creating land
    card = Card(kind='person', support=0)
    card.save()
    card.abilities.add(tap_ability)
    card.save()

    # creating creatures
    for power, endurance in product(range(0, 6), range(1, 6)):
        card = Card(kind='opinion', support=1, power=power, endurance=endurance)
        card.save()
Esempio n. 27
0
            card.sex = 'm'

        fav_date = row[4]
        try:
            card.fav_date = datetime.strptime(fav_date, '%d.%m.%Y')
        except:
            card.fav_date = None

        accum = row[7]
        card.accumulation = float(accum)

        phone = row[9]
        try:
            phone = str(int(phone))
        except:
            phone = str(phone)
        card.holder_phone = phone

        card.last_transaction_date = datetime.now().date()
        card.changes_date = datetime.now().date()

        card.org = org
        card.save()

        # try:
        #     card.save()
        # except django.db.utils.IntegrityError as er:
        #     continue

        pass
Esempio n. 28
0
 def test_new_card(self):
     new_card = Card(name='Cobblebrute',elo='9999',votes=5)
     new_card.save()
     response = self.client.get('/leaderboard/')
     return self.assertContains(response, '[5/2]')
Esempio n. 29
0
 def test_leaderboard_showing_oracle(self):
     good_card = Card(name='Inaction Injunction',elo=9999,votes=1000)
     good_card.save()
     response = self.client.get('/leaderboard/')
     return self.assertContains(response, 'Detain')
Esempio n. 30
0
def mass_add(request):
    if request.method == "POST":
        data = request.POST
        user = UserCustom.objects.get(user_id__exact=request.user.pk)
        try:
            form = MassCardForm(data)
            if form.is_valid():
                start = form.cleaned_data['code_start']
                end = form.cleaned_data['code_end']
                length = form.cleaned_data['code_length']
                pool = [str(x).zfill(length) for x in range(start, end + 1, 1)]
                for code in pool:
                    try:
                        card = Card.objects.get(code__exact=code,
                                                org_id__exact=user.org.pk)
                        exist = True
                    except:
                        card = Card()
                        exist = False

                    card.org = user.org

                    if not exist:
                        card.code = code
                        card.org = user.org
                        card.type = form.cleaned_data['type']
                        card.discount = form.cleaned_data['discount']
                        card.bonus = form.cleaned_data['bonus']
                        card.accumulation = form.cleaned_data['accumulation']
                        card.reg_date = datetime.now().date()
                        card.last_transaction_date = datetime.now().date()

                    else:
                        if form.cleaned_data['doubles'] == 'rewrite':
                            card.type = form.cleaned_data['type']
                            card.discount = form.cleaned_data['discount']
                            card.bonus = form.cleaned_data['bonus']
                            card.accumulation = form.cleaned_data[
                                'accumulation']
                            card.fio = ''
                            card.deleted = 'n'
                            card.reg_date = datetime.now().date()
                            card.last_transaction_date = datetime.now().date()
                            card.changes_date = None
                        elif form.cleaned_data['doubles'] == 'append':
                            card.type = form.cleaned_data['type']
                            card.discount = form.cleaned_data['discount']
                            card.bonus = form.cleaned_data['bonus']
                            card.accumulation = form.cleaned_data[
                                'accumulation']
                            card.deleted = 'n'
                            card.reg_date = datetime.now().date()
                            card.last_transaction_date = datetime.now().date()
                            card.changes_date = None
                        elif form.cleaned_data['doubles'] == 'ignore':
                            continue
                    card.save()

                return HttpResponseRedirect('/cards/')
        except Exception as e:
            response = {"result": e}
            return HttpResponse(response, content_type="application/json")

        response = {"result": "error"}
        return HttpResponse(json.dumps(response),
                            content_type="application/json")
Esempio n. 31
0
    def handle(self, **options):
        # Mandatory set
        if options['set'] is None:
            print("set argument is missing!")
            sys.exit()

        # set must be valid
        if len(options['set']) != 3:
            print("set is not valid, must be 3 digit")
            sys.exit()

        lang = options['lang'].lower() if len(options['lang']) == 2 else "en"
        set = options['set'].lower()

        with open("data/sets/" + lang + "/" + set + ".json") as f:
            cards = json.load(f)

            counter = 1
            for single_card in cards:
                card = Card.objects.filter(
                    scryfall_id=single_card['id']).first()

                if card is None:
                    card = Card(
                        language=lang,
                        set=set,
                        layout=single_card['layout'],
                        rarity=single_card['rarity'],
                        multiverse_id=single_card['multiverse_ids'].pop(0)
                        if len(single_card['multiverse_ids']) > 0 else "",
                        scryfall_id=single_card['id'],
                        collector_number=single_card['collector_number'],
                    )
                    print(
                        str(counter) + "/" + str(len(cards)) +
                        " New card from " + set + " (" + lang + ") : " +
                        single_card['layout'])  # nopep8

                    faces = []
                    types = []
                    if single_card['layout'] == "normal":
                        # NORMAL layout : 1 Face, 1 Type
                        card.name = single_card[
                            'printed_name'] if "printed_name" in single_card else single_card[
                                'name']

                        face = Face(
                            card=card,
                            illustration_id=single_card['illustration_id'])
                        face.descriptors = get_image_descriptions(
                            single_card['image_uris']['large'])  # nopep8
                        faces.append(face)

                        type = Type(
                            # Only get the card type (ex: Creature — Human Rogue)
                            type=single_card['type_line'].split(" — ").pop(0),
                            face=face,
                        )
                        types.append(type)
                    elif single_card['layout'] == "modal_dfc":
                        # MODAL DOUBLE FACE : 2 Faces, 2 Types
                        for single_face in single_card["card_faces"]:
                            face = Face(
                                card=card,
                                illustration_id=single_face["illustration_id"],
                                name=single_face['printed_name']
                                if "printed_name" in single_face else
                                single_face['name'])
                            face.descriptors = get_image_descriptions(
                                single_face['image_uris']['large'])  # nopep8
                            faces.append(face)

                            if card.name != "":
                                card.name = card.name + " // "

                            card.name = card.name + face.name

                            type = Type(
                                # Only get the card type (ex: Creature — Human Rogue)
                                type=single_face['type_line'].split(" — ").pop(
                                    0),
                                face=face,
                            )
                            types.append(type)

                    if len(faces) > 0 and len(types) > 0:
                        card.save()
                        for face in faces:
                            face.save()
                        for type in types:
                            type.save()
Esempio n. 32
0
class TestFormPage(BaseFunctionalTest):
    def setUp(self):
        super().setUp()
        self.card = Card(cardName="Chase Freedom",
                         bankName="Chase",
                         annualFee=0,
                         rewardsType="Cash Back",
                         rewardValue=0.01,
                         rewardsDisplay="5% cash back on select categories",
                         groceryMultiplier=2,
                         restMultiplier=2,
                         travelMultiplier=2,
                         gasMultiplier=2,
                         elseMultiplier=1,
                         APR=2,
                         bonusDisplay="dd",
                         bonusValue=2,
                         link="Chase.com",
                         creditScore=2,
                         bonusMinimumSpend=1,
                         bonusSpendMonths=1)

        self.card.save()
        self.browser.get(self.live_server_url + reverse("cards:forms"))

    # test valid data in form submit redirects to display_cards page
    def test_form_valid_data_submit(self):
        self.__check_form_data_submit_helper(1000)
        self.__check_valid_form_results_populated()

    # test no data in form submit stays in forms page
    def test_form_no_data_submit(self):
        self.__submit_form()
        self.__check_form_submit_redirection()

    # test invalid data in form submit stats in forms page
    def test_form_invalid_data_submit(self):
        self.__check_form_data_submit_helper('test')

    # helper to input data and redirect for form
    def __check_form_data_submit_helper(self, data):
        assert data is not None

        text_boxes = self.browser.find_elements_by_xpath(
            "//input[@type='number']")

        for textbox in text_boxes:
            textbox.send_keys(data)
            time.sleep(0.5)

        self.__submit_form()
        time.sleep(2)
        self.__check_form_submit_redirection()

    # find submit button and submit form
    def __submit_form(self):
        self.browser.find_element_by_tag_name("form").submit()

    # check submit form page redirection
    def __check_form_submit_redirection(self):
        self.assertEquals(self.browser.current_url,
                          self.live_server_url + reverse('cards:forms'))

    # check valid form populates results on  the page
    def __check_valid_form_results_populated(self):
        results = self.browser.find_elements_by_class_name("display")
        self.assertLess(0, len(results))
Esempio n. 33
0
    def handle(self, *args, **options):
        all_sets = CardSet.objects.all()

        if len(all_sets) == 0:
            raise CommandError(NO_CARDSETS)

        if len(args) == 1:
            sets = CardSet.objects.filter(name__icontains=args[0],
                country="GB")
            if len(sets) < 1:
                raise CommandError(NO_SETS_FOUND.format(args[0],
                    "\n".join([str(cs) for cs in all_sets])))
        else:
            sets = CardSet.objects.filter(country="GB")

        self.stdout.write("found card sets {0}\n".format(
            ", ".join([str(cs) for cs in sets])))
        self.stdout.write("Started Scrape command\n")

        card_no = re.compile("\s*(?P<card_no>\d+)/(?P<count>\d+)\s*")
        card_list_h2 = re.compile("((C|c)ard (L|l)ist(s)*)|(Setlist)")
        energy_type = re.compile(
            "(?P<energy_type>\w+) Energy \(((TCG)|(Basic))\)")

        for cs in sets:
            self.stdout.write("Processing '{0}'\n".format(cs.name))

            if cs.partial_url is None or cs.partial_url == "":
                raise CommandError("{0} does not have a valid URL".format(cs))

            html = json.load(urlopen(
                BASE_URL.format(
                    API_URL.format(
                        urlquote(cs.partial_url)))))['parse']['text']['*']
            try:
                h2 = (node
                      for node in BeautifulSoup(html).find_all("h2")
                      if node.find("span", "mw-headline") != None and
                          node.find(text=card_list_h2) != None).next()
                rows = (node.find_all("tr")
                       for node in h2.next_siblings
                       if not isinstance(node, NavigableString) and
                           node.find("b") != None and
                           node.find("b").find(text=cs.name) != None).next()
            except StopIteration:
                self.stdout.write(
                    "'{0}' does not have any valid cards\n".format(cs.name))
                continue

            cs.card_set.all().delete()

            for tr in rows:
                td = tr.find("td")
                if td is not None and td != -1:
                    match = card_no.match(td.text)
                    if match != None \
                        and int(match.group("count")) == cs.official_count:

                        node = td.next_sibling.next_sibling
                        name_node = node.next_sibling.next_sibling
                        type_node = name_node.next_sibling.next_sibling
                        rarity_node = type_node.next_sibling.next_sibling

                        if rarity_node.a is None and rarity_node.a != -1:
                            rarity_name = "None"
                        else:
                            rarity_name = rarity_node.a['title'].strip()

                        rarity, created = Rarity.objects.get_or_create(
                            name=rarity_name)

                        if created and rarity_node.a != None \
                            and rarity_node.a.img != None:

                            logo_temp = NamedTemporaryFile()
                            rarity_url = rarity_node.a.img['src']
                            logo_temp.write(urlopen(rarity_url).read())
                            logo_ext = urlparse(rarity_url).path.split('.')[-1]
                            logo_filename="{0}.{1}".format(str(rarity.id),
                                logo_ext)
                            logo_temp.flush()
                            rarity.logo.save(logo_filename, File(logo_temp))

                        if type_node.a is not None and type_node.a != -1:
                            card_type_name = type_node.a['title'].strip()
                            t_match = energy_type.match(card_type_name)
                            if t_match != None:
                                card_type_name = t_match.group("energy_type")
                        elif type_node.img is not None and type_node.img != -1 \
                            and type_node.img['alt'] == "Dragon-attack.png":
                            card_type_name = "Dragon"
                        else:
                            try:
                                card_type_name = CARD_TYPE_MAP[
                                    type_node.text.strip()]
                            except KeyError:
                                self.stderr.write(
                                    "Unrecognised type {0}".format(
                                    str(type_node)))

                        card_type, created =  CardType.objects.get_or_create(
                            name=card_type_name)

                        if created and type_node.a != None \
                            and type_node.a.img != None:

                            logo_temp = NamedTemporaryFile()
                            card_type_url = type_node.a.img['src']
                            logo_temp.write(urlopen(card_type_url).read())
                            logo_ext = urlparse(card_type_url
                                ).path.split('.')[-1]
                            logo_filename="{0}.{1}".format(str(card_type.id),
                                    logo_ext)
                            logo_temp.flush()
                            card_type.logo.save(logo_filename, File(logo_temp))

                        card = Card(card_no=match.group("card_no"),
                            card_set=cs,
                            name=name_node.text.encode('utf-8').strip(),
                            card_type=card_type, rarity=rarity)

                        if name_node.a is not None and name_node.a != -1:
                            card.url = BASE_URL.format(name_node.a['href'][1:])

                        card.save()
                        self.stdout.write("{0}/{1} - {2} ({3})\n".format(
                            str(card.card_no), str(cs.official_count),
                            card.name, cs.name))

            self.stdout.write("total cards {0}\n".format(
                str(cs.card_set.all().count())))
from cards.models import Card

Mlist = ['Nayeon', 'Jeongyeon', 'Momo', 'Sana', 'Jihyo', 'Mina', 'Dahyun', 'Chaeyoung', 'Tzuyu']
for member in Mlist:
    c = Card(number=91+Mlist.index(member), member=member, piece=0, album="More & more")
    c.save()

Esempio n. 35
0
 def test_leaderboard_showing_pt(self):
     new_card = Card(name='Kraken Hatchling',elo='9999',votes=10)
     new_card.save()
     response = self.client.get('/leaderboard/')
     return self.assertContains(response, '[0/4]')
Esempio n. 36
0
    def handle(self, *args, **options):
        all_sets = CardSet.objects.all()

        if len(all_sets) == 0:
            raise CommandError(NO_CARDSETS)

        if len(args) == 1:
            sets = CardSet.objects.filter(name__icontains=args[0], country="GB")
            if len(sets) < 1:
                raise CommandError(NO_SETS_FOUND.format(args[0], "\n".join([str(cs) for cs in all_sets])))
        else:
            sets = CardSet.objects.filter(country="GB")

        self.stdout.write("found card sets {0}\n".format(", ".join([str(cs) for cs in sets])))
        self.stdout.write("Started Scrape command\n")

        card_no = re.compile("\s*(?P<card_no>\d+)/(?P<count>\d+)\s*")
        card_list_h2 = re.compile("((C|c)ard (L|l)ist(s)*)|(Setlist)")
        energy_type = re.compile("(?P<energy_type>\w+) Energy \(((TCG)|(Basic))\)")

        for cs in sets:
            self.stdout.write("Processing '{0}'\n".format(cs.name))

            if cs.partial_url is None or cs.partial_url == "":
                raise CommandError("{0} does not have a valid URL".format(cs))

            html = json.load(urlopen(BASE_URL.format(API_URL.format(urlquote(cs.partial_url)))))["parse"]["text"]["*"]
            try:
                h2 = (
                    node
                    for node in BeautifulSoup(html).find_all("h2")
                    if node.find("span", "mw-headline") != None and node.find(text=card_list_h2) != None
                ).next()
                rows = (
                    node.find_all("tr")
                    for node in h2.next_siblings
                    if not isinstance(node, NavigableString)
                    and node.find("b") != None
                    and node.find("b").find(text=cs.name) != None
                ).next()
            except StopIteration:
                self.stdout.write("'{0}' does not have any valid cards\n".format(cs.name))
                continue

            cs.card_set.all().delete()

            for tr in rows:
                td = tr.find("td")
                if td is not None and td != -1:
                    match = card_no.match(td.text)
                    if match != None and int(match.group("count")) == cs.official_count:

                        node = td.next_sibling.next_sibling
                        name_node = node.next_sibling.next_sibling
                        type_node = name_node.next_sibling.next_sibling
                        rarity_node = type_node.next_sibling.next_sibling

                        if rarity_node.a is None and rarity_node.a != -1:
                            rarity_name = "None"
                        else:
                            rarity_name = rarity_node.a["title"].strip()

                        rarity, created = Rarity.objects.get_or_create(name=rarity_name)

                        if created and rarity_node.a != None and rarity_node.a.img != None:

                            logo_temp = NamedTemporaryFile()
                            rarity_url = rarity_node.a.img["src"]
                            logo_temp.write(urlopen(rarity_url).read())
                            logo_ext = urlparse(rarity_url).path.split(".")[-1]
                            logo_filename = "{0}.{1}".format(str(rarity.id), logo_ext)
                            logo_temp.flush()
                            rarity.logo.save(logo_filename, File(logo_temp))

                        if type_node.a is not None and type_node.a != -1:
                            card_type_name = type_node.a["title"].strip()
                            t_match = energy_type.match(card_type_name)
                            if t_match != None:
                                card_type_name = t_match.group("energy_type")
                        elif (
                            type_node.img is not None
                            and type_node.img != -1
                            and type_node.img["alt"] == "Dragon-attack.png"
                        ):
                            card_type_name = "Dragon"
                        else:
                            try:
                                card_type_name = CARD_TYPE_MAP[type_node.text.strip()]
                            except KeyError:
                                self.stderr.write("Unrecognised type {0}".format(str(type_node)))

                        card_type, created = CardType.objects.get_or_create(name=card_type_name)

                        if created and type_node.a != None and type_node.a.img != None:

                            logo_temp = NamedTemporaryFile()
                            card_type_url = type_node.a.img["src"]
                            logo_temp.write(urlopen(card_type_url).read())
                            logo_ext = urlparse(card_type_url).path.split(".")[-1]
                            logo_filename = "{0}.{1}".format(str(card_type.id), logo_ext)
                            logo_temp.flush()
                            card_type.logo.save(logo_filename, File(logo_temp))

                        card = Card(
                            card_no=match.group("card_no"),
                            card_set=cs,
                            name=name_node.text.encode("utf-8").strip(),
                            card_type=card_type,
                            rarity=rarity,
                        )

                        if name_node.a is not None and name_node.a != -1:
                            card.url = BASE_URL.format(name_node.a["href"][1:])

                        card.save()
                        self.stdout.write(
                            "{0}/{1} - {2} ({3})\n".format(
                                str(card.card_no), str(cs.official_count), card.name, cs.name
                            )
                        )

            self.stdout.write("total cards {0}\n".format(str(cs.card_set.all().count())))
Esempio n. 37
0
def maintenance(request):
    response = {}
    if request.method == "POST":
        post = request.POST
        user = UserCustom.objects.get(user_id__exact=request.user.pk)
        if "cmd" in post:
            if post["cmd"] == "save":  # сохранение карты
                if "data" in post:
                    data = json.loads(post["data"])
                    try:
                        form = CardForm(data)
                        if form.is_valid():
                            try:
                                #if "collision" in post:
                                #if post['collision']
                                card = Card.objects.get(
                                    code__exact=form.cleaned_data['code'],
                                    org_id__exact=user.org.pk)

                            except ObjectDoesNotExist as e:
                                card = Card()
                            card.code = form.cleaned_data['code']
                            card.holder_name = form.cleaned_data['holder_name']
                            card.holder_phone = form.cleaned_data[
                                'holder_phone']
                            card.bonus = form.cleaned_data['bonus']
                            card.discount = form.cleaned_data['discount']
                            card.accumulation = form.cleaned_data[
                                'accumulation']
                            card.type = form.cleaned_data['type']
                            card.changes_date = datetime.now().date()
                            if not card.reg_date:
                                card.reg_date = datetime.now().date()
                                card.last_transaction_date = datetime.now(
                                ).date()
                            card.org = user.org
                            card.save()
                            response = {"result": "ok"}
                            return HttpResponse(
                                json.dumps(response),
                                content_type="application/json")
                    except:
                        response = {"result": "error"}
                        return HttpResponse(json.dumps(response),
                                            content_type="application/json")
            if post["cmd"] == "get":  # получение данных по карте
                if "data" in post:
                    data = json.loads(post["data"])
                    try:
                        card = Card.objects.filter(
                            code__exact=data["code"],
                            org_id__exact=user.org.pk).get()

                        date_func = lambda a: '' if a is None else a.strftime(
                            '%Y-%m-%d')
                        data = {
                            "code":
                            card.code,
                            "holder_name":
                            card.holder_name,
                            "holder_phone":
                            card.holder_phone,
                            "accumulation":
                            card.accumulation,
                            "bonus":
                            card.bonus,
                            "discount":
                            card.discount,
                            "type":
                            card.type,
                            "reg_date":
                            date_func(card.reg_date),
                            "changes_date":
                            date_func(card.changes_date),
                            "last_transaction_date":
                            date_func(card.last_transaction_date)
                        }
                        response = {"result": "ok", "data": data}
                        response = json.dumps(response)
                        return HttpResponse(response,
                                            content_type="application/json")
                    except Exception as err:
                        response = {"result": "error", "msg": err}
                        return HttpResponse(json.dumps(response),
                                            content_type="application/json")
            if post["cmd"] == "delete":  # получение данных по карте
                if "data" in post:
                    data = json.loads(post["data"])
                    try:
                        for code in data:
                            card = Card.objects.filter(
                                code__exact=code,
                                org_id__exact=user.org.pk).get()
                            card.deleted = 'y'
                            card.save()
                        response = {"result": "ok", "data": data}
                        response = json.dumps(response)
                        return HttpResponse(response,
                                            content_type="application/json")
                    except Exception as err:
                        response = {"result": "error", "msg": err}
                        return HttpResponse(json.dumps(response),
                                            content_type="application/json")
            if post["cmd"] == "restore":  # получение данных по карте
                if "data" in post:
                    data = json.loads(post["data"])
                    try:
                        for code in data:
                            card = Card.objects.filter(
                                code__exact=code,
                                org_id__exact=user.org.pk).get()
                            card.deleted = 'n'
                            card.save()
                        response = {"result": "ok", "data": data}
                        response = json.dumps(response)
                        return HttpResponse(response,
                                            content_type="application/json")
                    except Exception as err:
                        response = {"result": "error", "msg": err}
                        return HttpResponse(json.dumps(response),
                                            content_type="application/json")
Esempio n. 38
0
def add(request):
    try:
        context = {
            "decks": Deck.objects.all().order_by('name'),
            "deck_types":
            DeckType.objects.all().order_by('sort_order', 'name')
        }
        name = request.POST['name'].strip()
        if len(name) > 0:
            d = Deck(name=name,
                     notes=request.POST['notes'],
                     deckType=DeckType.objects.get(
                         pk=int(request.POST['deckType'])))
            d.save()
            p = re.compile("(\\d+)x (.+)")
            issue_list = []
            cards = None
            if len(request.POST['list'].strip().replace('\r\n', '\n')) != 0:
                main = request.POST['list'].strip().replace('\r\n',
                                                            '\n').split('\n')
            else:
                main = []
            if len(request.POST['sideboard'].strip().replace('\r\n',
                                                             '\n')) != 0:
                total = main + request.POST['sideboard'].strip().replace(
                    '\r\n', '\n').split('\n')
            else:
                total = main
            print(total)
            for i, line in enumerate(total):
                m = p.match(line.strip())
                if m is None:
                    issue_list.append(
                        "Line {} is badly formed. Card could not be added.".
                        format(line))
                else:
                    c = Card.objects.filter(name__iexact=m.groups()[1])
                    if len(c) == 0:
                        #try json
                        if cards is None:
                            f = open(os.path.join(settings.BASE_DIR,
                                                  'AllCards.json'),
                                     'r',
                                     encoding='utf8')
                            cards = json.load(f)
                            f.close()
                        if m.groups()[1] in cards:
                            c = Card(name=m.groups()[1],
                                     text=cards[m.groups()[1]]['text'],
                                     notes="",
                                     addMana=False)
                            #mana cost
                            if "manaCost" in cards[m.groups()[1]]:
                                c.manaCost = cards[
                                    m.groups()[1]]['manaCost'].replace(
                                        '}{', ',').replace('{', '').replace(
                                            '}', '').replace('/', '')
                            #ptl
                            if "power" in cards[m.groups()[1]]:
                                c.power = cards[m.groups()[1]]["power"]
                            if "toughness" in cards[m.groups()[1]]:
                                c.toughness = cards[m.groups()[1]]["toughness"]
                            if "loyalty" in cards[m.groups()[1]]:
                                c.loyalty = cards[m.groups()[1]]["loyalty"]
                            c.save()
                            #types
                            if "supertypes" in cards[m.groups()[1]]:
                                for type in cards[m.groups()[1]]['supertypes']:
                                    t = Type.objects.filter(name__exact=type,
                                                            typeType__exact=2)
                                    if len(t) == 0:
                                        t = Type(name=type, typeType=2)
                                        t.save()
                                    else:
                                        t = t[0]
                                    c.types.add(t)
                            if "types" in cards[m.groups()[1]]:
                                for type in cards[m.groups()[1]]['types']:
                                    t = Type.objects.filter(name__exact=type,
                                                            typeType__exact=3)
                                    if len(t) == 0:
                                        t = Type(name=type, typeType=3)
                                        t.save()
                                    else:
                                        t = t[0]
                                    c.types.add(t)
                            if "subtypes" in cards[m.groups()[1]]:
                                for type in cards[m.groups()[1]]['subtypes']:
                                    t = Type.objects.filter(name__exact=type,
                                                            typeType__exact=1)
                                    if len(t) == 0:
                                        t = Type(name=type, typeType=1)
                                        t.save()
                                    else:
                                        t = t[0]
                                    c.types.add(t)
                            #sets
                            f = open(
                                os.path.join(settings.BASE_DIR,
                                             'SetList.json'), 'r')
                            sets = json.load(f)
                            f.close()
                            if "printings" in cards[m.groups()[1]]:
                                for code in cards[m.groups()[1]]["printings"]:
                                    for jset in sets:
                                        if jset["code"] == code:
                                            if jset["type"] not in bad_set_types:
                                                set = Set.objects.filter(
                                                    name__exact=jset["name"])
                                                if len(set) == 0:
                                                    set = Set(
                                                        name=jset["name"])
                                                    set.save()
                                                else:
                                                    set = set[0]
                                                set.cards.add(c)
                                            break
                            if i < len(main):
                                dc = DeckCard(card=c,
                                              count=int(m.groups()[0]),
                                              deck=d)
                            else:
                                dc = DeckCard(card=c,
                                              sideboard_count=int(
                                                  m.groups()[0]),
                                              deck=d)
                            dc.save()
                        else:
                            issue_list.append(
                                "Could not find a card named {}. Card could not be added."
                                .format(m.groups()[1]))
                    else:
                        if i < len(main):
                            dc = DeckCard(card=c[0],
                                          count=int(m.groups()[0]),
                                          deck=d)
                        else:
                            dc = DeckCard(card=c[0],
                                          sideboard_count=int(m.groups()[0]),
                                          deck=d)
                        dc.save()
            if len(issue_list) > 0:
                context['saved'] = '\\n'.join(issue_list)
                context['new_deck'] = d.id
            else:
                return redirect('/decks/{}'.format(d.id))
        else:
            context['error'] = "Deck must have a name."
        if mobile(request):
            return render(request, 'decks/m_add.html', context)
        else:
            return render(request, 'decks/add.html', context)
    except KeyError:
        if mobile(request):
            return render(request, 'decks/m_add.html', context)
        else:
            return render(request, 'decks/add.html', context)
    except OSError as ex:
        print(ex)
Esempio n. 39
0
 def test_sorting_is_working(self):
     good_card = Card(name='Inaction Injunction',elo=9999,votes=1000)
     good_card.save()
     response = self.client.get('/leaderboard/')
     first_card = response.context['cards'][0]
     return self.assertEqual(first_card.name,'Inaction Injunction')
Esempio n. 40
0
def xls2sql(source_path, source_file):
    har = source_file.split('.')[:1][0]  # значение характеристики позиции, источник-имя файла
    rb = xlrd.open_workbook("%s\%s" % (source_path, source_file))
    sheet = rb.sheet_by_index(0)

    #предотвращаем дублирование записей
    #    sql="SELECT `har`,`decimal` FROM `cards` WHERE `har`=%d" % har
    #    cursor.execute(sql)
    #    data =  cursor.fetchall()
    data = Card.objects.filter(Har=har)
    sDecimal = [x['Decimal'] for x in
                data.distinct().values('Decimal')]#составляем список децимальный номеров, которые есть в БД
    fields = sheet.row_values(0)
    for rownum in range(1, sheet.nrows):
        row = sheet.row_values(rownum)

        if row[1] and row[5]:  # поля Имя и дата не должны быть пустыми
            DecMore = ""
            fullDecimal = ""
            #проверка входнных данных
            try:
                row[0] = '%03d' % int(row[0])
                fullDecimal = row[0]
                for i in range(2, 4):
                    if not row[i]:
                        ErrorInLog('[%s.%s]:поле %s пусто\n'.decode('utf-8') % (har, row[0], fields[i]))
            except ValueError, err:
                #  если децималный номер нестандартный
                pat = re.compile(r"^(\d{1,3})((-|\.).*)")  # патерн для рег. выражения. 2ая группа - допустимые символы
                #  после которых идет дополнительная часть
                reResult = pat.match(row[0])
                fullDecimal = row[0]
                if reResult:  # Если децимальный номер не валидный то
                    row[0] = reResult.group(1)  # разделяем децимальный номер на валидную часть
                    DecMore = reResult.group(2)  # и не валидную
                else:
                    ErrorInLog('[%s.%s]:%s\n'.decode('utf-8') % (har, row[0], err))
            # проверяем есть ли совпаедния с БД
            if not fullDecimal in [("%03d" % validDecimal) + DecMore.strip() for validDecimal in sDecimal]:
                try:
                    row[5] = convertExcelTime(row[5], source_file)
                except TypeError:
                    ErrorInLog(u'[%s.%s]:Ошибка заполнения времени %s' % (har, row[0], row[5]))

                if unicode(row[2]).strip:
                    xlsProject = Project.objects.get_or_create(Name=row[2])
                else:
                    xlsProject = 'Не указан'
                xlsDeveloper = Developer.objects.get_or_create(Name=row[3],
                                                               defaults={
                                                                   'Devision':
                                                                       Devision.objects.get_or_create(Name='КО')[
                                                                           0]})
                try:
                    save = Card(Har=har.encode('utf-8'), Decimal=row[0],
                                DecimalMore=DecMore,
                                Name=row[1].encode('utf-8'),
                                Project=xlsProject[0],
                                Developer=xlsDeveloper[0],
                                CreatingDate=row[5])
                    save.save()
                except ValueError, ValidationError:
                    logFile = open(LOG_FILE, 'a')
                    logFile.write('[%s.%s]:Ошибка ввода в БД' % (har, row[0]))
                    print '[%s.%s]:Ошибка ввода в БД' % (har, row[0])
                    logFile.close()
                except:
Esempio n. 41
0
 def form_valid(self, form):
     course = Course.objects.get(id=self.request.GET.get('course'))
     card = Card(course=course, **form.cleaned_data)
     card.save()
     return super().form_valid(form)