def query_userid_key(trace_id,
                     user_id,
                     organization_id=None,
                     filter_expression=None,
                     convert_response=None,
                     is_cw_logger=False):
    if (is_cw_logger):
        logger = common_utils.begin_cw_logger(trace_id, __name__,
                                              inspect.currentframe())
    else:
        logger = common_utils.begin_logger(trace_id, __name__,
                                           inspect.currentframe())
    key_conditions = {
        'UserID': {
            'AttributeValueList': [user_id],
            'ComparisonOperator': 'EQ'
        }
    }
    if (organization_id):
        key_conditions['OrganizationID'] = {
            'AttributeValueList': [organization_id],
            'ComparisonOperator': 'EQ'
        }
    result = DB_utils.query(trace_id,
                            Tables.PM_AFFILIATION,
                            key_conditions,
                            filter_expression,
                            is_cw_logger=is_cw_logger)
    if result and convert_response:
        result = common_utils.convert_list_response(trace_id,
                                                    result,
                                                    RESPONSE_AFFILIATION,
                                                    is_cw_logger=is_cw_logger)
    return common_utils.response(result, logger)
Example #2
0
def query_organization_id(trace_id, organization_id, filter_expression=None):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'OrganizationID': {
            'AttributeValueList': [organization_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(trace_id, Tables.PM_LATEST_CHECK_RESULT,
                            key_conditions, filter_expression)
    return common_utils.response(result, pm_logger)
def query(trace_id, security_check_webhook_id):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'SecurityCheckWebhookID': {
            'AttributeValueList': [security_check_webhook_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(trace_id,
                            Tables.PM_SECURITY_CHECK_WEBHOOK_CALL_HISTORY,
                            key_conditions, None)
    return common_utils.response(result, pm_logger)
Example #4
0
def get_projects(trace_id, project_id, filter_expression=None,
                 convert_response=None):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'ProjectID': {
            'AttributeValueList': [project_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(trace_id, Tables.PM_PROJECTS,
                            key_conditions, filter_expression)

    if convert_response:
        result = common_utils.convert_list_response(
            trace_id, result, RESPONSE_PROJECTS)
    return common_utils.response(result, pm_logger)
def query_daily_check_key(trace_id, awsaccount, executed_date):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'AWSAccount': {
            'AttributeValueList': [awsaccount],
            'ComparisonOperator': 'EQ'
        }
    }
    key_conditions['ExecutedDate'] = {
        'AttributeValueList': [executed_date],
        'ComparisonOperator': 'EQ'
    }

    result = DB_utils.query(trace_id,
                            Tables.PM_DAILY_CHECK_EXECUTED_AWSACCOUNTS,
                            key_conditions, None)
    return common_utils.response(result, pm_logger)
Example #6
0
def query_key_by_check_history_id(trace_id, project_id, organization_id,
                                  check_history_id):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    filter = Attr('CheckHistoryID').eq(check_history_id)
    key_conditions = {
        'OrganizationID': {
            'AttributeValueList': [organization_id],
            'ComparisonOperator': 'EQ'
        },
        'ProjectID': {
            'AttributeValueList': [project_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(trace_id, Tables.PM_LATEST_CHECK_RESULT,
                            key_conditions, filter)
    return common_utils.response(result, pm_logger)
def get_check_history_by_status(trace_id,
                                check_history_id,
                                check_status,
                                convert_response=None):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'CheckHistoryID': {
            'AttributeValueList': [check_history_id],
            'ComparisonOperator': 'EQ'
        }
    }
    filter = Attr('CheckStatus').eq(check_status)
    result = DB_utils.query(trace_id, Tables.PM_CHECK_HISTORY, key_conditions,
                            filter)
    if convert_response:
        result = common_utils.convert_response(trace_id, result,
                                               RESPONSE_HISTORY)
    return common_utils.response(result, pm_logger)
def query_awscoop(trace_id,
                  coop_id,
                  filter_expression=None,
                  convert_response=None):
    pm_logger = common_utils.begin_logger(trace_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'CoopID': {
            'AttributeValueList': [coop_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(trace_id, Tables.PM_AWSACCOUNTCOOPS,
                            key_conditions, filter_expression)

    if convert_response:
        result = common_utils.convert_list_response(trace_id, result,
                                                    RESPONSE_AWSCOOPS,
                                                    RESPONSE_REQUIRED)
    return common_utils.response(result, pm_logger)
def query(user_id,
          organization_id,
          filter_expression=None,
          convert_response=None):
    pm_logger = common_utils.begin_logger(user_id, __name__,
                                          inspect.currentframe())
    key_conditions = {
        'UserID': {
            'AttributeValueList': [user_id],
            'ComparisonOperator': 'EQ'
        },
        'OrganizationID': {
            'AttributeValueList': [organization_id],
            'ComparisonOperator': 'EQ'
        }
    }
    result = DB_utils.query(user_id, Tables.PM_AFFILIATION, key_conditions,
                            filter_expression)
    if result and convert_response:
        result = common_utils.convert_list_response(user_id, result,
                                                    RESPONSE_AFFILIATION)
    return common_utils.response(result, pm_logger)