示例#1
0
def reindex_all_claims(orcidid, since=None, ignore_errors=False):
    """
    Procedure that will re-play all claims
    that were modified since a given starting point.
    """
    
    last_check = get_date(since or '1974-11-09T22:56:52.518001Z')
    recs_modified = set()
    
    with app.session_scope() as session:
        author = matcher.retrieve_orcid(orcidid)
        claimed = set()
        removed = set()
        for claim in session.query(ClaimsLog).filter(
                        and_(ClaimsLog.orcidid == orcidid, ClaimsLog.created > last_check)
                        ).all():
            if claim.status in ('claimed', 'updated', 'forced'):
                claimed.add(claim.bibcode)
            elif claim.status == 'removed':
                removed.add(claim.bibcode)

        with app.session_scope() as session:    
            for bibcode in removed:
                r = session.query(Records).filter_by(bibcode=bibcode).first()
                if r is None:
                    continue
                rec = r.toJSON()
                if _remove_orcid(rec, orcidid):
                    r.claims = json.dumps(rec.get('claims'))
                    r.updated = get_date()
                    recs_modified.add(bibcode)
        
            for bibcode in claimed:
                r = session.query(Records).filter_by(bibcode=bibcode).first()
                if r is None:
                    continue
                rec = r.toJSON()

                claim = {'bibcode': bibcode, 'orcidid': orcidid}
                claim.update(author.get('facts', {}))
                try:
                    _claims = update_record(rec, claim)
                    if _claims:
                        r.claims = json.dumps(rec.get('claims', {}))
                        r.updated = get_date()
                        recs_modified.add(bibcode)
                except Exception, e:
                    if ignore_errors:
                        app.logger.error(u'Error processing {0} {1}'.format(bibcode, orcidid))
                    else:
                        raise e
                    
                    
            session.commit()
        
        return list(recs_modified)
示例#2
0
def sync_buffs():
    with open(os.path.join(root_dir, "app/database/data/buffs.json"),
              "r") as file:
        data = json.load(file)

        while True:
            response = input(
                "Enter a class name (e.g. 'Eliotrope'), type 'update all' to update all classes, or type 'q' to move onto item buffs: "
            )
            if response == "q":
                break
            with session_scope() as db_session:
                if response == "update all":
                    for class_name in data["spells"]:
                        sync_spell_buffs(db_session, class_name,
                                         data["spells"][class_name])
                    break
                elif response in data["spells"]:
                    all_spell_data = data["spells"][response]
                    sync_spell_buffs(db_session, response, all_spell_data)
                else:
                    print(
                        "'{}' class does not exist, please try again.".format(
                            response))

        name_to_item_record_map = {}

        for r in data["items"]:
            name_to_item_record_map[r["name"]] = r

        while True:
            response = input(
                "Enter an item name (e.g. 'Crimson Dofus') to update its buffs, type 'update all' to update all buffs for items in the file, 'add missing buffs' to only add buffs to items that are missing them, or type 'q' to quit: "
            )
            if response == "q":
                break
            with session_scope() as db_session:
                if response == "update all":
                    for record in data["items"]:
                        update_or_create_item_buff(db_session, record["name"],
                                                   record, False)
                    break
                elif response == "add missing buffs":
                    for record in data["items"]:
                        update_or_create_item_buff(db_session, record["name"],
                                                   record, True)
                    break
                elif response in name_to_item_record_map:
                    record = name_to_item_record_map[response]
                    update_or_create_item_buff(db_session, response, record,
                                               False)
                else:
                    print(
                        "That item does not have a buff or a typo was made, please try again."
                    )
示例#3
0
def sync_set():
    with open(os.path.join(app_root, "app/database/data/sets.json"), "r") as file:
        data = json.load(file)

        name_to_record_map = {}

        for set_data in data:
            name_to_record_map[set_data["name"]["en"]] = set_data

        while True:
            response = input(
                "Enter a set name, type 'update all' to update all sets, type 'add missing sets' to only add sets that are missing, or type 'q' to quit: "
            )
            if response == "q":
                break
            with session_scope() as db_session:
                if response == "update all":
                    for set_data in data:
                        create_or_update_set(
                            db_session, set_data["name"]["en"], set_data, False
                        )
                    break
                elif response == "add missing sets":
                    for set_data in data:
                        create_or_update_set(
                            db_session, set_data["name"]["en"], set_data, True
                        )
                    break
                elif response in name_to_record_map:
                    record = name_to_record_map[response]
                    create_or_update_set(db_session, response, record, False)
                else:
                    print(
                        "The set {} does not exist. Please try again.".format(response)
                    )
示例#4
0
def sync_custom_set_tag():
    print("Loading and processing file...")
    with open(
        os.path.join(app_root, "app/database/data/custom_set_tags.json"), "r",
    ) as file:
        data = json.load(file)
        name_to_record_map = {}

        for r in data:
            name_to_record_map[r["name"]["en"]] = r

        should_prompt = True
        while should_prompt:
            tag_name = input(
                "Enter tag name, e.g. 'Str', type 'update all' to update all tags, or 'q' to quit: "
            )
            if tag_name == "q":
                return
            with session_scope() as db_session:
                if tag_name == "update all":
                    should_prompt = False
                    create_or_update_all_custom_set_tags(db_session, data)
                elif tag_name in name_to_record_map:
                    record = name_to_record_map[tag_name]
                    create_or_update_custom_set_tag(db_session, tag_name, record)
示例#5
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            equipped_item_id = kwargs.get("equipped_item_id")
            weapon_element_mage = kwargs.get("weapon_element_mage")
            stats = kwargs.get("stats")
            equipped_item = db_session.query(ModelEquippedItem).get(
                equipped_item_id)
            check_owner(equipped_item.custom_set)
            db_session.query(ModelEquippedItemExo).filter_by(
                equipped_item_id=equipped_item_id).delete(
                    synchronize_session=False)
            exo_models = map(
                lambda stat_line: ModelEquippedItemExo(
                    stat=Stat(stat_line.stat),
                    value=stat_line.value,
                    equipped_item_id=equipped_item_id,
                ),
                stats,
            )
            if stats:
                db_session.add_all(exo_models)
            slot_name = (db_session.query(ModelItemSlotTranslation).filter(
                ModelItemSlotTranslation.locale == "en").filter(
                    ModelItemSlotTranslation.item_slot_id ==
                    equipped_item.slot.uuid).one().name)
            if weapon_element_mage and slot_name != "Weapon":
                raise GraphQLError(
                    _("Invalid element mage on non-weapon item."))
            equipped_item.weapon_element_mage = (
                WeaponElementMage(weapon_element_mage)
                if weapon_element_mage else None)
            equipped_item.custom_set.last_modified = datetime.utcnow()

        return MageEquippedItem(equipped_item=equipped_item)
示例#6
0
 def unequip_item(self, item_slot_id):
     with session_scope() as session:
         equipped_item = (session.query(ModelEquippedItem).filter_by(
             custom_set_id=self.uuid,
             item_slot_id=item_slot_id).one_or_none())
         if equipped_item:
             session.delete(equipped_item)
示例#7
0
def sync_spell_buffs(db_session, class_name, spells):
    print(class_name)
    name_to_spell_record_map = {}

    for spell in spells:
        name_to_spell_record_map[spell["name"]] = spell

    while True:
        response = input(
            "Enter a spell name, type 'update all' to update all spell buffs for this class, 'add missing buffs' to only add buffs to spells that are missing them, or type 'q' to quit: "
        )
        if response == "q":
            break
        with session_scope() as db_session:
            if response == "update all":
                for spell in spells:
                    update_or_create_spell_buff(db_session, spell["name"],
                                                spell, False)
                break
            elif response == "add missing buffs":
                for spell in spells:
                    update_or_create_spell_buff(db_session, spell["name"],
                                                spell, True)
                break
            elif response in name_to_spell_record_map:
                spell_data = name_to_spell_record_map[response]
                update_or_create_spell_buff(db_session, response, spell_data,
                                            False)
            else:
                print(
                    "That spell either does not have a buff or a typo was made, please try again."
                )
示例#8
0
def sync_item_type():
    print("Loading and processing file...")
    with open(
            os.path.join(app_root, "app/database/data/item_types.json"),
            "r",
    ) as file:
        data = json.load(file)
        name_to_record_map = {}

        for r in data:
            name_to_record_map[r["en"]] = r

        should_prompt_item = True
        while should_prompt_item:
            item_name = input(
                "Enter item type name, e.g. 'Prysmaradite', type 'update all' to update all item types, or 'q' to quit: "
            )
            if item_name == "q":
                return
            with session_scope() as db_session:
                if item_name == "update all":
                    should_prompt_item = False
                    for record in data:
                        recreate_item_type_translations(
                            db_session, record["en"], record)
                elif item_name in name_to_record_map:
                    record = name_to_record_map[item_name]
                    recreate_item_type_translations(db_session, item_name,
                                                    record)
示例#9
0
def record_claims(bibcode, claims, authors=None):
    """
    Stores results of the processing in the database.
    
    :param: bibcode
    :type: string
    :param: claims
    :type: dict
    """
    
    if not isinstance(claims, basestring):
        claims = json.dumps(claims)
    if authors and not isinstance(authors, basestring):
        authors = json.dumps(authors)
        
    with app.session_scope() as session:
        if not isinstance(claims, basestring):
            claims = json.dumps(claims)
        r = session.query(Records).filter_by(bibcode=bibcode).first()
        if r is None:
            t = get_date()
            r = Records(bibcode=bibcode, 
                        claims=claims, 
                        created=t,
                        updated=t,
                        authors=authors
                        )
            session.add(r)
        else:
            r.updated = get_date()
            r.claims = claims
            if authors:
                r.authors = authors
            session.merge(r)
        session.commit()
示例#10
0
def sync_spell():
    print("Loading and processing file...")
    with open(os.path.join(app_root, "app/database/data/spells.json"), "r") as file:
        data = json.load(file)
        name_to_record_map = {}

        for r in data:
            class_name = r["names"]["en"]
            for pair in r["spells"]:
                for spell in pair:
                    name_to_record_map[spell["name"]["en"]] = spell

        should_prompt_spell = True
        while should_prompt_spell:
            response = input(
                "Enter spell name, e.g. 'Blindness' or multiple spell names separated "
                "by commas, type 'update all' to update all spells in file, or 'q' to quit: "
            )
            if response == "q":
                return
            with session_scope() as db_session:
                if response == "update all":
                    should_prompt_spell = False
                    for record in data:
                        update_spell(db_session, record["name"]["en"], record)
                else:
                    spell_names = response.split(",")
                    print(spell_names)
                    for name in spell_names:
                        spell_name = name.strip()
                        if spell_name in name_to_record_map:
                            record = name_to_record_map[spell_name]
                            update_spell(db_session, spell_name, record)
示例#11
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            username = kwargs.get("username")
            email = kwargs.get("email")
            password = kwargs.get("password")
            validation.validate_registration(username, email, password)
            try:
                if current_user.is_authenticated:
                    raise GraphQLError(_("You are already logged in."))
                user = ModelUserAccount(
                    username=username,
                    email=email,
                    password=ModelUserAccount.generate_hash(password),
                    locale=str(get_locale()),
                )
                token = encode_token(user.email, verify_email_salt)
                verify_url = generate_url("verify_email.verify_email", token)
                template = template_env.get_template("verify_email.html")
                content = template.render(display_name=username,
                                          verify_url=verify_url)
                db_session.add(user)
                db_session.flush()
                q.enqueue(send_email, user.email,
                          _("Verify your DofusLab account"), content)
                login_user(user)
                save_custom_sets(db_session)
            except Exception as e:
                raise GraphQLError(_("An error occurred while registering."))

        return RegisterUser(user=user, ok=True)
示例#12
0
    def mutate(self, info, **kwargs):
        custom_set_id = kwargs.get("custom_set_id")
        with session_scope() as db_session:
            old_custom_set = db_session.query(ModelCustomSet).get(
                custom_set_id)
            custom_set = get_or_create_custom_set(None, db_session)
            custom_set.name = (_(
                "%(old_name)s copy",
                old_name=old_custom_set.name)[:MAX_NAME_LENGTH]
                               if old_custom_set.name else _("Copy"))
            custom_set.level = old_custom_set.level
            custom_set.parent_custom_set_id = old_custom_set.uuid
            for stat in base_stat_list + scrolled_stat_list:
                setattr(custom_set.stats, stat,
                        getattr(old_custom_set.stats, stat))
            for old_equipped_item in old_custom_set.equipped_items:
                equipped_item = ModelEquippedItem(
                    custom_set_id=custom_set.uuid,
                    item_slot_id=old_equipped_item.item_slot_id,
                    item_id=old_equipped_item.item_id,
                    weapon_element_mage=old_equipped_item.weapon_element_mage,
                )
                db_session.add(equipped_item)
                db_session.flush()
                for old_exo in old_equipped_item.exos:
                    exo = ModelEquippedItemExo(
                        stat=old_exo.stat,
                        value=old_exo.value,
                        equipped_item_id=equipped_item.uuid,
                    )
                    db_session.add(exo)

        return CopyCustomSet(custom_set=custom_set)
示例#13
0
def test_db():
    init_db()
    info_test = Info(content='test', link='link.test')

    with session_scope() as session:
        assert info_test == session.query(Info).filter(
            Info.content == 'test').all()
示例#14
0
def send_email(email, subject, content):
    with session_scope() as db_session:
        ses = boto3.client(
            "ses",
            region_name=os.getenv("SES_REGION"),
            aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
            aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
        )
        ses.send_email(
            Source=os.getenv("SES_EMAIL_SOURCE"),
            Destination={"ToAddresses": [email]},
            Message={
                "Subject": {
                    "Data": subject
                },
                "Body": {
                    "Html": {
                        "Data": content
                    }
                },
            },
        )
        user = db_session.query(ModelUserAccount).filter_by(email=email).one()
        user.email_sent = True
        return True
示例#15
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            stats = kwargs.get("stats")
            custom_set = get_or_create_custom_set(custom_set_id, db_session)
            edit_custom_set_stats(custom_set, stats)

        return EditCustomSetStats(custom_set=custom_set)
示例#16
0
    def mutate(self, info, **kwargs):
        custom_set_id = kwargs.get("custom_set_id")
        with session_scope() as db_session:
            custom_set = db_session.query(ModelCustomSet).get(custom_set_id)
            check_owner(custom_set)
            db_session.delete(custom_set)

        return DeleteCustomSet(ok=True)
示例#17
0
def add_weapons():
    print("Adding weapons to database")
    with open(os.path.join(app_root, "app/database/data/weapons.json"), "r") as file:
        with session_scope() as db_session:
            data = json.load(file)
            for record in data:

                oneoff.sync_item.create_item(db_session, record)
示例#18
0
def add_sets_and_items():
    print("Adding sets to database")
    with open(os.path.join(app_root, "app/database/data/sets.json"), "r") as file:
        with session_scope() as db_session:
            data = json.load(file)
            for record in data:
                create_set(db_session, record)

    print("Adding items to database")
    with open(os.path.join(app_root, "app/database/data/items.json"), "r") as file:
        with session_scope() as db_session:
            data = json.load(file)
            for record in data:
                if record["itemType"] == "Living object":
                    continue

                oneoff.sync_item.create_item(db_session, record)
示例#19
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            item_slot_id = kwargs.get("item_slot_id")
            custom_set = db_session.query(ModelCustomSet).get(custom_set_id)
            check_owner(custom_set)
            custom_set.unequip_item(item_slot_id)

        return DeleteCustomSetItem(custom_set=custom_set)
示例#20
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            set_id = kwargs.get("set_id")
            custom_set = get_or_create_custom_set(custom_set_id, db_session)
            set_obj = db_session.query(ModelSet).get(set_id)
            custom_set.equip_set(set_obj, db_session)

        return EquipSet(custom_set=custom_set)
示例#21
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            item_slot_id = kwargs.get("item_slot_id")
            item_id = kwargs.get("item_id")
            custom_set = get_or_create_custom_set(custom_set_id, db_session)
            custom_set.equip_item(item_id, item_slot_id, db_session)

        return UpdateCustomSetItem(custom_set=custom_set)
示例#22
0
 def mutate(self, info, **kwargs):
     with session_scope():
         user = current_user._get_current_object()
         classic = kwargs.get("classic")
         if current_user.is_authenticated:
             user.settings.classic = classic
         session["classic"] = classic
         refresh()
         return ChangeClassic(ok=True)
示例#23
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            name = kwargs.get("name")
            level = kwargs.get("level")
            custom_set = get_or_create_custom_set(custom_set_id, db_session)
            edit_custom_set_metadata(custom_set, name, level)

        return EditCustomSetMetadata(custom_set=custom_set)
示例#24
0
def load_data(date_time):
    """Query data from database"""
    # extract function to extract day, month, year in date_added of database
    # a simple query data if the day of query is the same of Info.date_added
    # use context manager of session_scope()
    with session_scope() as session:
        return session.query(Info).filter(
            extract('day', Info.date_added) == date_time.day,
            extract('month', Info.date_added) == date_time.month,
            extract('year', Info.date_added) == date_time.year).all()
示例#25
0
    def mutate(self, info, **kwargs):
        with session_scope() as db_session:
            custom_set_id = kwargs.get("custom_set_id")
            item_ids = kwargs.get("item_ids")
            custom_set = get_or_create_custom_set(custom_set_id, db_session)
            items = db_session.query(ModelItem).filter(
                ModelItem.uuid.in_(item_ids))
            custom_set.equip_items(items, db_session)

        return EquipMultipleItems(custom_set=custom_set)
示例#26
0
 def mutate(self, info, **kwargs):
     if not current_user.is_authenticated:
         raise GraphQLError(_("You are not logged in."))
     item_id = kwargs.get("item_id")
     is_favorite = kwargs.get("is_favorite")
     user_account_id = current_user.get_id()
     with session_scope() as db_session:
         ModelFavoriteItem.toggle_favorite(db_session, user_account_id,
                                           item_id, is_favorite)
     return ToggleFavoriteItem(user=current_user._get_current_object())
示例#27
0
def save_data(url, items):
    """Save data crawled to database"""
    data = json.loads(extract_data(url, items))
    # data = extract_data(url, items)
    with session_scope() as session:
        for link, content in data.items():
            info = Info(link=link, content=content)
            session.add(info)

        session.commit()
示例#28
0
 def mutate(self, info, **kwargs):
     locale = kwargs.get("locale")
     if not locale in supported_languages:
         raise GraphQLError(_("Received unsupported locale."))
     with session_scope():
         user = current_user._get_current_object()
         if current_user.is_authenticated:
             user.locale = locale
         session["locale"] = locale
         refresh()
         return ChangeLocale(ok=True)
示例#29
0
def clean_data():
    """Clean old data from database"""
    # use context manager of session_scope()
    with session_scope() as session:
        old_data = session.query(Info).filter(
            extract('day', Info.date_added) < datetime.today().day,
            extract('month', Info.date_added) <= datetime.today().month,
            extract('year', Info.date_added) <= datetime.today().year).all()
        for data in old_data:
            session.delete(data)

        session.commit()
示例#30
0
def sync_name():
    while True:
        file_name = input(
            "Enter JSON file name without extension ({}) or q to quit: ".
            format(", ".join(allowed_file_names)))
        if file_name == "q":
            break

        if file_name in allowed_file_names:
            with session_scope() as db_session:
                update_name(db_session, file_name)
        else:
            print("File name not allowed or is incorrect. Please try again.")
示例#31
0
def verify_email(token):
    with session_scope() as db_session:
        email = decode_token(token, verify_email_salt)
        if not email:
            return redirect(REDIRECT_URL_FORMAT.format(REDIRECT_URL,
                                                       "invalid"))
        user = db_session.query(ModelUserAccount).filter_by(email=email).one()
        if user.verified:
            return redirect(
                REDIRECT_URL_FORMAT.format(REDIRECT_URL, "already_verified"))
        user.verified = True
        db_session.add(user)
        return redirect(REDIRECT_URL_FORMAT.format(REDIRECT_URL, "success"))
示例#32
0
def add_classes_and_spells():
    print("Adding classes to database")
    with open(os.path.join(app_root, "app/database/data/spells.json"), "r") as file:
        with session_scope() as db_session:
            data = json.load(file)
            for record in data:
                en_name = record["names"]["en"]
                class_object = ModelClass(
                    face_image_url=face_url_base.format(en_name),
                    male_sprite_image_url=male_sprite_url_base.format(en_name),
                    female_sprite_image_url=female_sprite_url_base.format(en_name),
                )
                db_session.add(class_object)
                db_session.flush()

                for locale in record["names"]:
                    class_translation = ModelClassTranslation(
                        class_id=class_object.uuid,
                        locale=locale,
                        name=record["names"][locale],
                    )
                    db_session.add(class_translation)
                    class_object.name.append(class_translation)

                for spell_pair in record["spells"]:
                    spell_pair_object = ModelSpellVariantPair(
                        class_id=class_object.uuid
                    )
                    db_session.add(spell_pair_object)
                    db_session.flush()

                    for spell in spell_pair:
                        spell_object = ModelSpell(
                            spell_variant_pair_id=spell_pair_object.uuid,
                            image_url=spell["imageUrl"],
                            is_trap=spell.get("isTrap", False),
                        )
                        db_session.add(spell_object)
                        db_session.flush()

                        for locale in spell["name"]:
                            spell_translation = ModelSpellTranslation(
                                spell_id=spell_object.uuid,
                                locale=locale,
                                name=spell["name"][locale],
                                description=spell["description"][locale],
                            )
                            db_session.add(spell_translation)
                            spell_object.spell_translation.append(spell_translation)

                        create_spell_stats(db_session, spell, spell_object)
示例#33
0
def mark_processed(bibcode):
    """Updates the date on which the record has been processed (i.e.
    something has consumed it
    
    :param: bibcode
    :type: str
    
    :return: None
    """
    
    with app.session_scope() as session:
        r = session.query(Records).filter_by(bibcode=bibcode).first()
        if r is None:
            raise IgnorableException('Nonexistant record for {0}'.format(bibcode))
        r.processed = get_date()
        session.commit()
        return True        
示例#34
0
def update_author(author):
    """Updates existing AuthorInfo records. 
    
    It will check for new information. If there is a difference,
    updates the record and also records the old values.
    
    :param: author - AuthorInfo instance
    
    :return: AuthorInfo object
    
    :sideeffect: Will insert new records (ChangeLog) and also update
     the author instance
    """
    try:
        new_facts = harvest_author_info(author.orcidid)
    except:
        return author.toJSON()
    
    info = author.toJSON()
    with session_scope() as session:
        old_facts = info['facts']
        attrs = set(new_facts.keys())
        attrs = attrs.union(old_facts.keys())
        is_dirty = False
        
        for attname in attrs:
            if old_facts.get(attname, None) != new_facts.get(attname, None):
                session.add(ChangeLog(key=u'{0}:update:{1}'.format(author.orcidid, attname), 
                           oldvalue=json.dumps(old_facts.get(attname, None)),
                           newvalue=json.dumps(new_facts.get(attname, None))))
                is_dirty = True
        
        if bool(author.account_id) != bool(new_facts.get('authorized', False)):
            author.account_id = new_facts.get('authorized', False) and 1 or None 
        
        if is_dirty:
            author.facts = json.dumps(new_facts)
            author.name = new_facts.get('name', author.name)
            aid=author.id
            session.commit()
            return session.query(AuthorInfo).filter_by(id=aid).first().toJSON()
        else:
            return info
示例#35
0
def retrieve_orcid(orcid):
    """
    Finds (or creates and returns) model of ORCID
    from the dbase. It will automatically update our
    knowledge about the author every time it gets
    called.
    
    :param orcid - String (orcid id)
    :return - OrcidModel datastructure
    """
    with session_scope() as session:
        u = session.query(AuthorInfo).filter_by(orcidid=orcid).first()
        if u is not None:
            return update_author(u)
        u = create_orcid(orcid)
        session.add(u)
        session.commit()
        
        return session.query(AuthorInfo).filter_by(orcidid=orcid).first().toJSON()
示例#36
0
def retrieve_record(bibcode):
    """
    Gets a record from the database (creates one if necessary)
    """
    with app.session_scope() as session:
        r = session.query(Records).filter_by(bibcode=bibcode).first()
        if r is None:
            r = Records(bibcode=bibcode)
            session.add(r)
        out = r.toJSON()
        
        metadata = retrieve_metadata(bibcode)
        authors = metadata.get('author', [])
        
        if out.get('authors') != authors:
            r.authors = json.dumps(authors)
            out['authors'] = authors
        
        session.commit()
        return out