def get_item_info_for_search_result(recid): """ Get the item's info from MARC in order to create a search result with more details @param recid: identify the record. Primary key of bibrec. @type recid: int @return book's informations (author, editor and number of copies) """ book_author = ' '.join(get_fieldvalues(recid, "100__a") + \ get_fieldvalues(recid, "100__u")) book_editor = ' , '.join(get_fieldvalues(recid, "260__a") + \ get_fieldvalues(recid, "260__b") + \ get_fieldvalues(recid, "260__c")) book_copies = ' '.join(get_fieldvalues(recid, "964__a")) if not book_copies: book_copies = db.get_number_copies(recid) book_infos = (book_author, book_editor, book_copies) return book_infos
def perform_request_record(req, request_type, recid, uid, data, ln=CFG_SITE_LANG): """Handle 'major' record related requests like fetching, submitting or deleting a record, cancel editing or preparing a record for merging. """ response = {} if request_type == "newRecord": # Create a new record. new_recid = reserve_record_id() new_type = data["newType"] if new_type == "empty": # Create a new empty record. create_cache_file(recid, uid) response["resultCode"], response["newRecID"] = 6, new_recid elif new_type == "template": # Create a new record from XML record template. template_filename = data["templateFilename"] template = get_record_template(template_filename) if not template: response["resultCode"] = 108 else: record = create_record(template)[0] if not record: response["resultCode"] = 109 else: record_add_field(record, "001", controlfield_value=str(new_recid)) create_cache_file(new_recid, uid, record, True) response["resultCode"], response["newRecID"] = 7, new_recid elif new_type == "clone": # Clone an existing record (from the users cache). existing_cache = cache_exists(recid, uid) if existing_cache: try: record = get_cache_file_contents(recid, uid)[2] except: # if, for example, the cache format was wrong (outdated) record = get_bibrecord(recid) else: # Cache missing. Fall back to using original version. record = get_bibrecord(recid) record_delete_field(record, "001") record_add_field(record, "001", controlfield_value=str(new_recid)) create_cache_file(new_recid, uid, record, True) response["resultCode"], response["newRecID"] = 8, new_recid elif request_type == "getRecord": # Fetch the record. Possible error situations: # - Non-existing record # - Deleted record # - Record locked by other user # - Record locked by queue # A cache file will be created if it does not exist. # If the cache is outdated (i.e., not based on the latest DB revision), # cacheOutdated will be set to True in the response. record_status = record_exists(recid) existing_cache = cache_exists(recid, uid) read_only_mode = False if data.has_key("inReadOnlyMode"): read_only_mode = data["inReadOnlyMode"] if record_status == 0: response["resultCode"] = 102 elif record_status == -1: response["resultCode"] = 103 elif not read_only_mode and not existing_cache and record_locked_by_other_user(recid, uid): response["resultCode"] = 104 elif ( not read_only_mode and existing_cache and cache_expired(recid, uid) and record_locked_by_other_user(recid, uid) ): response["resultCode"] = 104 elif not read_only_mode and record_locked_by_queue(recid): response["resultCode"] = 105 else: if data.get("deleteRecordCache"): delete_cache_file(recid, uid) existing_cache = False pending_changes = [] disabled_hp_changes = {} if read_only_mode: if data.has_key("recordRevision"): record_revision_ts = data["recordRevision"] record_xml = get_marcxml_of_revision(recid, record_revision_ts) record = create_record(record_xml)[0] record_revision = timestamp_to_revision(record_revision_ts) pending_changes = [] disabled_hp_changes = {} else: # a normal cacheless retrieval of a record record = get_bibrecord(recid) record_revision = get_record_last_modification_date(recid) pending_changes = [] disabled_hp_changes = {} cache_dirty = False mtime = 0 undo_list = [] redo_list = [] elif not existing_cache: record_revision, record = create_cache_file(recid, uid) mtime = get_cache_mtime(recid, uid) pending_changes = [] disabled_hp_changes = {} undo_list = [] redo_list = [] cache_dirty = False else: # TODO: This try except should be replaced with something nicer, # like an argument indicating if a new cache file is to # be created try: cache_dirty, record_revision, record, pending_changes, disabled_hp_changes, undo_list, redo_list = get_cache_file_contents( recid, uid ) touch_cache_file(recid, uid) mtime = get_cache_mtime(recid, uid) if not latest_record_revision(recid, record_revision) and get_record_revisions(recid) != (): # This sould prevent from using old cache in case of # viewing old version. If there are no revisions, # it means we should skip this step because this # is a new record response["cacheOutdated"] = True except: record_revision, record = create_cache_file(recid, uid) mtime = get_cache_mtime(recid, uid) pending_changes = [] disabled_hp_changes = {} cache_dirty = False undo_list = [] redo_list = [] if data["clonedRecord"]: response["resultCode"] = 9 else: response["resultCode"] = 3 revision_author = get_record_revision_author(recid, record_revision) last_revision_ts = revision_to_timestamp(get_record_last_modification_date(recid)) revisions_history = get_record_revision_timestamps(recid) number_of_physical_copies = get_number_copies(recid) bibcirc_details_URL = create_item_details_url(recid, ln) can_have_copies = can_record_have_physical_copies(recid) response["cacheDirty"], response["record"], response["cacheMTime"], response["recordRevision"], response[ "revisionAuthor" ], response["lastRevision"], response["revisionsHistory"], response["inReadOnlyMode"], response[ "pendingHpChanges" ], response[ "disabledHpChanges" ], response[ "undoList" ], response[ "redoList" ] = ( cache_dirty, record, mtime, revision_to_timestamp(record_revision), revision_author, last_revision_ts, revisions_history, read_only_mode, pending_changes, disabled_hp_changes, undo_list, redo_list, ) response["numberOfCopies"] = number_of_physical_copies response["bibCirculationUrl"] = bibcirc_details_URL response["canRecordHavePhysicalCopies"] = can_have_copies # Set tag format from user's session settings. try: tagformat_settings = session_param_get(req, "bibedit_tagformat") tagformat = tagformat_settings[recid] except KeyError: tagformat = CFG_BIBEDIT_TAG_FORMAT response["tagFormat"] = tagformat elif request_type == "submit": # Submit the record. Possible error situations: # - Missing cache file # - Cache file modified in other editor # - Record locked by other user # - Record locked by queue # - Invalid XML characters # If the cache is outdated cacheOutdated will be set to True in the # response. if not cache_exists(recid, uid): response["resultCode"] = 106 elif not get_cache_mtime(recid, uid) == data["cacheMTime"]: response["resultCode"] = 107 elif cache_expired(recid, uid) and record_locked_by_other_user(recid, uid): response["resultCode"] = 104 elif record_locked_by_queue(recid): response["resultCode"] = 105 else: try: tmp_result = get_cache_file_contents(recid, uid) record_revision = tmp_result[1] record = tmp_result[2] pending_changes = tmp_result[3] # disabled_changes = tmp_result[4] xml_record = print_rec(record) record, status_code, list_of_errors = create_record(xml_record) if status_code == 0: response["resultCode"], response["errors"] = 110, list_of_errors elif not data["force"] and not latest_record_revision(recid, record_revision): response["cacheOutdated"] = True else: save_xml_record(recid, uid) response["resultCode"] = 4 except: response["resultCode"] = CFG_BIBEDIT_AJAX_RESULT_CODES_REV["error_wrong_cache_file_format"] elif request_type == "revert": revId = data["revId"] job_date = "%s-%s-%s %s:%s:%s" % re_revdate_split.search(revId).groups() revision_xml = get_marcxml_of_revision(recid, job_date) save_xml_record(recid, uid, revision_xml) if cache_exists(recid, uid): delete_cache_file(recid, uid) response["resultCode"] = 4 elif request_type == "cancel": # Cancel editing by deleting the cache file. Possible error situations: # - Cache file modified in other editor if cache_exists(recid, uid): if get_cache_mtime(recid, uid) == data["cacheMTime"]: delete_cache_file(recid, uid) response["resultCode"] = 5 else: response["resultCode"] = 107 else: response["resultCode"] = 5 elif request_type == "deleteRecord": # Submit the record. Possible error situations: # - Record locked by other user # - Record locked by queue # As the user is requesting deletion we proceed even if the cache file # is missing and we don't check if the cache is outdated or has # been modified in another editor. existing_cache = cache_exists(recid, uid) pending_changes = [] if has_copies(recid): response["resultCode"] = CFG_BIBEDIT_AJAX_RESULT_CODES_REV["error_physical_copies_exist"] elif existing_cache and cache_expired(recid, uid) and record_locked_by_other_user(recid, uid): response["resultCode"] = CFG_BIBEDIT_AJAX_RESULT_CODES_REV["error_rec_locked_by_user"] elif record_locked_by_queue(recid): response["resultCode"] = CFG_BIBEDIT_AJAX_RESULT_CODES_REV["error_rec_locked_by_queue"] else: if not existing_cache: record_revision, record, pending_changes, deactivated_hp_changes, undo_list, redo_list = create_cache_file( recid, uid ) else: try: record_revision, record, pending_changes, deactivated_hp_changes, undo_list, redo_list = get_cache_file_contents( recid, uid )[ 1: ] except: record_revision, record, pending_changes, deactivated_hp_changes = create_cache_file(recid, uid) record_add_field(record, "980", " ", " ", "", [("c", "DELETED")]) undo_list = [] redo_list = [] update_cache_file_contents( recid, uid, record_revision, record, pending_changes, deactivated_hp_changes, undo_list, redo_list ) save_xml_record(recid, uid) delete_related_holdingpen_changes(recid) # we don't need any changes # related to a deleted record response["resultCode"] = 10 elif request_type == "deleteRecordCache": # Delete the cache file. Ignore the request if the cache has been # modified in another editor. if cache_exists(recid, uid) and get_cache_mtime(recid, uid) == data["cacheMTime"]: delete_cache_file(recid, uid) response["resultCode"] = 11 elif request_type == "prepareRecordMerge": # We want to merge the cache with the current DB version of the record, # so prepare an XML file from the file cache, to be used by BibMerge. # Possible error situations: # - Missing cache file # - Record locked by other user # - Record locked by queue # We don't check if cache is outdated (a likely scenario for this # request) or if it has been modified in another editor. if not cache_exists(recid, uid): response["resultCode"] = 106 elif cache_expired(recid, uid) and record_locked_by_other_user(recid, uid): response["resultCode"] = 104 elif record_locked_by_queue(recid): response["resultCode"] = 105 else: save_xml_record(recid, uid, to_upload=False, to_merge=True) response["resultCode"] = 12 return response