def delete(token_info, id):
    login_id, is_login = otherutils.get_login(token_info)
    data_list, is_objectid, is_error, resp = otherutils.get_data_list(
        id, login_id, is_login, coll_contribution)

    if is_error:
        return resp

    contribution_admins = data_list[0]['contributionAdmins']

    # check if the logged in user's login is included in contribution admin list
    is_admin_user = otherutils.check_login_admin(token_info["login"],
                                                 contribution_admins)
    if not is_admin_user:
        msg = {
            "reason": "Contribution admin list must contain logged in user",
            "error": "Bad Request: " + request.url,
        }
        msg_json = jsonutils.create_log_json("Contribution", "POST", msg)
        logging.error("Contribution POST " + json.dumps(msg_json))
        return rs_handlers.bad_request(msg_json)

    if (is_objectid):
        coll_contribution.delete_one({cfg.FIELD_OBJECTID: ObjectId(id)})
        msg = {"id": str(id)}
        msg_json = jsonutils.create_log_json("Contribution", "DELETE", msg)
        logging.info("Contribution DELETE " + json.dumps(msg_json))
        return rs_handlers.entry_deleted('ID', id)
def search(token_info=None, name=None):
    # args = request.args
    is_list = False
    query = dict()

    login_id, is_login = otherutils.get_login(token_info)

    # building query parematers
    query = query_params.format_query_status_login(query, login_id, is_login)

    # if there is no query word, it is simply requesting list of all records
    if name is None:
        is_list = True

    if is_list:
        # return the list of all records
        out_json = mongoutils.get_result(coll_contribution, query)
    else:
        try:
            query = query_params.format_query_contribution(name, query)
        except Exception as ex:
            msg = {
                "reason": "The query is wrong or bad argument",
                "error": "Bad Request: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Contribution", "SEARCH", msg)
            logging.error("Contribution SEARCH " + json.dumps(msg_json))
            return rs_handlers.bad_request(msg_json)

        try:
            # get result using query
            out_json = mongoutils.get_result(coll_contribution, query)
        except Exception as ex:
            msg = {
                "reason": "The query is wrong or bad argument",
                "error": "Bad Request: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Contribution", "SEARCH", msg)
            logging.error("Contribution SEARCH " + json.dumps(msg_json))
            return rs_handlers.bad_request(msg_json)

    if out_json is None:
        out_json = []

    msg = {"search": "Contribution search performed with : " + str(name)}
    msg_json = jsonutils.create_log_json("Contribution", "SEARCH", msg)
    logging.info("Contribution SEARCH " + json.dumps(msg))

    return out_json
def get(token_info=None, id=None):
    login_id, is_login = otherutils.get_login(token_info)

    data_list, is_objectid, is_error, resp = otherutils.get_data_list(
        id, login_id, is_login, coll_contribution)

    # if getting data process failed, that is is_error is true, return error reponse
    if is_error:
        return resp
    jsonutils.convert_obejctid_from_dataset_json(data_list[0])
    out_json = mongoutils.construct_json_from_query_list(data_list[0])
    msg_json = jsonutils.create_log_json("Contribution", "GET",
                                         {"id": str(id)})
    logging.info("Contribution GET " +
                 json.dumps(jsonutils.remove_objectid_from_dataset(msg_json)))

    return out_json
def talents_search(token_info=None, id=None):
    login_id, is_login = otherutils.get_login(token_info)

    contribution_dataset, status_code = mongoutils.get_contribution_dataset_from_objectid(
        coll_contribution, id, login_id, is_login)

    if status_code == '200':
        if contribution_dataset is not None:
            talent_dataset = contribution_dataset.get_talents()
            for talent in talent_dataset:
                talent[
                    "contributionAdmins"] = contribution_dataset.contributionAdmins
        else:
            msg = {
                "reason":
                "There is no contribution dataset with given id, "
                "or you don't have privilege to view this: " + str(id),
                "error":
                "Not Authorized: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.not_authorized(msg_json)
    else:
        if status_code == "401":
            msg = {
                "reason":
                "Not authorized to view the contribution dataset with given id: "
                + str(id),
                "error":
                "Not Authorized: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.not_authorized(msg_json)
        elif status_code == '404':
            msg = {
                "reason":
                "There is no contribution dataset with given id: " + str(id),
                "error":
                "Not Found: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.not_found(msg_json)
        else:
            msg = {
                "reason":
                "The query was not successfully performed: " + str(id),
                "error": "Bad Request: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.bad_request(msg_json)

    if talent_dataset is None:
        msg = {
            "reason":
            "There is no Talent with given contribution id: " + str(id),
            "error": "Not Found: " + request.url,
        }
        msg_json = jsonutils.create_log_json("Talent", "GET", msg)
        logging.error("Talent SEARCH " + json.dumps(msg_json))
        return rs_handlers.not_found(msg_json)

    msg = {
        "search":
        "Talent data in the contribution dataset with given id : " + str(id)
    }
    msg_json = jsonutils.create_log_json("Talent", "GET", msg)
    logging.info("Talent GET " + json.dumps(msg))

    return talent_dataset
def alltalentssearch(token_info=None, name=None):
    query = dict()
    is_list = False

    login_id, is_login = otherutils.get_login(token_info)

    query = query_params.format_query_status_login(query, login_id, is_login)

    if name is None:
        is_list = True

    if is_list:
        out_json = mongoutils.get_result(coll_contribution, query)
    else:
        try:
            query = query_params.format_query_talent(name, query)
        except Exception as ex:
            msg = {
                "reason": "The query is wrong or bad argument",
                "error": "Bad Request: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.bad_request(msg_json)

        try:
            out_json = mongoutils.get_result(coll_contribution, query)
        except Exception as ex:
            msg = {
                "reason": "The query is wrong or bad argument",
                "error": "Bad Request: " + request.url,
            }
            msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
            logging.error("Talent SEARCH " + json.dumps(msg_json))
            return rs_handlers.bad_request(msg_json)

    return_json = []
    if out_json is None:
        return_json = []
    else:
        if is_list:  # list all
            if isinstance(out_json, list):
                for in_json in out_json:
                    contribution_id = in_json["id"]
                    if in_json['talents'] is not None:
                        for talent in in_json['talents']:
                            talent["contributionId"] = contribution_id
                            return_json.append(talent)
            else:
                contribution_id = out_json["id"]
                talent = out_json['talents']
                talent["contributionId"] = contribution_id
                return_json.append(talent)
        else:  # extract out talent with the given name
            if isinstance(out_json, list):
                for tmp_json in out_json:
                    contribution_id = tmp_json["id"]
                    talents_json = tmp_json["talents"]
                    # TODO this is the case of only 1 args that is name.
                    #  If there are more args this should be updated
                    for tmp_talent_json in talents_json:
                        talent_json = None
                        if tmp_talent_json["name"] == name:
                            talent_json = tmp_talent_json
                            talent_json["contributionId"] = contribution_id
                            return_json.append(talent_json)
            else:
                talents_json = out_json["talents"]
                contribution_id = out_json["id"]
                # TODO this is the case of only 1 args that is name.
                #  If there are more args this should be updated
                for tmp_talent_json in talents_json:
                    talent_json = None
                    if tmp_talent_json["name"] == name:
                        talent_json = tmp_talent_json
                        talent_json["contributionId"] = contribution_id
                        return_json.append(talent_json)
    if is_list:
        msg = {"GET": "Talent list"}
        msg_json = jsonutils.create_log_json("Talent", "GET", msg)
        logging.info("Talent GET " + json.dumps(msg_json))
    else:
        msg = {"search": "Talent search performed with " + str(name)}
        msg_json = jsonutils.create_log_json("Talent", "SEARCH", msg)
        logging.info("Talent SEARCH " + json.dumps(msg_json))

    return return_json