API - Items module

This module creates the Remediation Items resources on a provided AWS API Gateway.

Example

Typical Usage::

from stacks.resources.api_gateway.resources import items

items.create(stack, created_api_gateway, dynamodb_items_table_arn, auth, question_updater_function_arn)

__create_delete_item(ddb_role, dynamodb_pkey_id, dynamodb_table, resource, response_model, request_validator, auth)

Create the DELETE Remediation Item methods on the provided REST API Gateway Resource.

Creates a DELETE method on the /{model_name}/{id} resource to delete a single Remediation Item from the DynamoDB.

Attributes:

Name	Type	Description
ddb_role	aws_cdk.aws_iam.Role	The IAM Role to access the DB from the API Gateway.
dynamodb_pkey_id	str	DynamoDB Table primary key name.
dynamodb_table	aws_cdk.aws_dynamodb.Table	The DynamoDB Table.
resource	aws_cdk.aws_apigateway.Resource	API Gateway resource where the resources and methods should be created.
response_model	aws_cdk.aws_apigateway.Model	Model for the response validation.
request_validator	aws_cdk.aws_apigateway.RequestValidator	Validator for the request.
auth	aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer	Authorization for the endpoint.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_delete_item(
    ddb_role: Role, 
    dynamodb_pkey_id: str, 
    dynamodb_table: Table, 
    resource: apigateway.Resource, 
    response_model: apigateway.Model,
    request_validator: apigateway.RequestValidator, 
    auth: apigateway.CognitoUserPoolsAuthorizer
    ):
    """Create the DELETE Remediation Item methods on the provided REST API Gateway Resource.

    Creates a DELETE method on the `/{model_name}/{id}` resource to delete a single Remediation Item from the DynamoDB.

    Attributes:
        ddb_role (aws_cdk.aws_iam.Role): The IAM Role to access the DB from the API Gateway.
        dynamodb_pkey_id (str): DynamoDB Table primary key name.
        dynamodb_table (aws_cdk.aws_dynamodb.Table): The DynamoDB Table.
        resource (aws_cdk.aws_apigateway.Resource): API Gateway resource where the resources and methods should be created.
        response_model (aws_cdk.aws_apigateway.Model): Model for the response validation.
        request_validator (aws_cdk.aws_apigateway.RequestValidator): Validator for the request.
        auth (aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer): Authorization for the endpoint.
    """

    delete_integration = apigateway.AwsIntegration(
        service="dynamodb",
        action="DeleteItem",
        options=apigateway.IntegrationOptions(
            credentials_role=ddb_role,
            integration_responses=[
                apigateway.IntegrationResponse(
                    status_code="200",
                    selection_pattern="200",
                    response_parameters={
                        "method.response.header.Access-Control-Allow-Origin": "'*'"
                    },                      
                ),
                __ERROR_INTEGRATION_RESPONSE_400,
                __ERROR_INTEGRATION_RESPONSE_500
            ],
            request_templates={
                'application/json': json.dumps({
                    "Key": {
                        f"{dynamodb_pkey_id}": {
                        "S": "$method.request.path.id"
                        }
                    },
                    "TableName": f"{dynamodb_table.table_name}"
                    }),
            },
        ),
    )    

    success_response_200 = apigateway.MethodResponse(
        status_code='200',
        response_models={ "application/json": response_model}, 
        response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }
    )

    resource.add_method(
        'DELETE', 
        integration=delete_integration, 
        method_responses=[
            success_response_200,
            __ERROR_METHOD_RESPONSE_400, 
            __ERROR_METHOD_RESPONSE_500
        ],
        request_validator=request_validator,
        authorizer=auth, 
        authorization_type=apigateway.AuthorizationType.COGNITO
    )

__create_get_item(ddb_role, dynamodb_pkey_id, dynamodb_table, resource, response_model, request_validator, auth)

Create the GET Remediation Item methods on the provided REST API Gateway Resource.

Creates a GET method on the /{model_name}/{id} resource to fetch a single remediation item from the DynamoDB.

Attributes:

Name	Type	Description
ddb_role	aws_cdk.aws_iam.Role	The IAM Role to access the DB from the API Gateway.
dynamodb_pkey_id	str	DynamoDB Table primary key name.
dynamodb_table	aws_cdk.aws_dynamodb.Table	The DynamoDB Table.
resource	aws_cdk.aws_apigateway.Resource	API Gateway resource where the resources and methods should be created.
response_model	aws_cdk.aws_apigateway.Model	Model for the response validation.
auth	aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer	Authorization for the endpoint.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_get_item(ddb_role: Role, dynamodb_pkey_id: str, dynamodb_table: Table, resource: apigateway.Resource, response_model: apigateway.Model, request_validator: apigateway.RequestValidator,  auth: apigateway.CognitoUserPoolsAuthorizer):
    """Create the GET Remediation Item methods on the provided REST API Gateway Resource.

    Creates a GET method on the `/{model_name}/{id}` resource to fetch a single remediation item from the DynamoDB.

    Attributes:
        ddb_role (aws_cdk.aws_iam.Role): The IAM Role to access the DB from the API Gateway.
        dynamodb_pkey_id (str): DynamoDB Table primary key name.
        dynamodb_table (aws_cdk.aws_dynamodb.Table): The DynamoDB Table.
        resource (aws_cdk.aws_apigateway.Resource): API Gateway resource where the resources and methods should be created.
        response_model (aws_cdk.aws_apigateway.Model): Model for the response validation.
        auth (aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer): Authorization for the endpoint.
    """

    get_integration = apigateway.AwsIntegration(
        service="dynamodb",
        action="GetItem",
        options= apigateway.IntegrationOptions(
            credentials_role=ddb_role,
            integration_responses=[
                apigateway.IntegrationResponse(
                    status_code="200",
                    selection_pattern="200",
                    response_parameters={
                        "method.response.header.Access-Control-Allow-Origin": "'*'"
                    },
                    response_templates= {
                        "application/json": '''
                            #set($inputRoot = $input.path('$').Item)
                            {
                                "item_title": "$inputRoot.item_title.S",
                                "item_effort": $inputRoot.item_effort.N,
                                "item_id": "$inputRoot.item_id.S",
                                "item_desc": "$inputRoot.item_desc.S",
                                "item_lense": "$inputRoot.item_lense.S",
                                "item_pillar": "$inputRoot.item_pillar.S",
                                "item_hri": [
                                    #foreach($elem in $inputRoot.item_hri.L) 
                                        "$elem.S"
                                    #if($foreach.hasNext),#end
                                #end
                                ]

                            }               
                        '''
                    }
                ),
                __ERROR_INTEGRATION_RESPONSE_400,
                __ERROR_INTEGRATION_RESPONSE_500
            ],
            request_templates= {
                'application/json': json.dumps({
                    "Key": {
                        dynamodb_pkey_id: {
                        "S": "$method.request.path.id"
                        }
                    },
                    "TableName": dynamodb_table.table_name
                    }),
            },
        ),
    )

    success_response_200 = apigateway.MethodResponse(
        status_code='200',
        response_models={ "application/json": response_model}, 
        response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }
    )


    resource.add_method(
        'GET', 
        integration=get_integration, 
        method_responses=[
            success_response_200,
            __ERROR_METHOD_RESPONSE_400, 
            __ERROR_METHOD_RESPONSE_500
        ],
        request_validator=request_validator,
        authorizer=auth, 
        authorization_type=apigateway.AuthorizationType.COGNITO
    )

__create_get_items(ddb_role, dynamodb_table, resource, response_model, request_validator, auth)

Create the GET Remediation Item methods on the provided REST API Gateway Resource.

Creates a GET method on the /{model_name} resource to fetch all Remediation Items from the DynamoDB.

Attributes:

Name	Type	Description
ddb_role	aws_cdk.aws_iam.Role	The IAM Role to access the DB from the API Gateway.
dynamodb_pkey_id	str	DynamoDB Table primary key name.
dynamodb_table	aws_cdk.aws_dynamodb.Table	The DynamoDB Table.
resource	aws_cdk.aws_apigateway.Resource	API Gateway resource where the resources and methods should be created.
response_model	aws_cdk.aws_apigateway.Model	Model for the response validation.
auth	aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer	Authorization for the endpoint.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_get_items(ddb_role: Role, dynamodb_table: Table, resource: apigateway.Resource, response_model: apigateway.Model, request_validator: apigateway.RequestValidator,  auth: apigateway.CognitoUserPoolsAuthorizer):
    """Create the GET Remediation Item methods on the provided REST API Gateway Resource.

    Creates a GET method on the `/{model_name}` resource to fetch all Remediation Items from the DynamoDB.

    Attributes:
        ddb_role (aws_cdk.aws_iam.Role): The IAM Role to access the DB from the API Gateway.
        dynamodb_pkey_id (str): DynamoDB Table primary key name.
        dynamodb_table (aws_cdk.aws_dynamodb.Table): The DynamoDB Table.
        resource (aws_cdk.aws_apigateway.Resource): API Gateway resource where the resources and methods should be created.
        response_model (aws_cdk.aws_apigateway.Model): Model for the response validation.
        auth (aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer): Authorization for the endpoint.
    """

    get_integration = apigateway.AwsIntegration(
        service="dynamodb",
        action="Scan",
        options= apigateway.IntegrationOptions(
            credentials_role=ddb_role,
            integration_responses=[
                apigateway.IntegrationResponse(
                    status_code="200",
                    selection_pattern="200",
                    response_parameters={
                        "method.response.header.Access-Control-Allow-Origin": "'*'"
                    },                    
                    response_templates= {
                        "application/json": '''
                            #set($inputRoot = $input.path('$'))
                            [
                                #foreach($item in $inputRoot.Items)
                                {
                                    "item_id": "$item.item_id.S",
                                    "item_title": "$item.item_title.S",
                                    "item_desc": "$item.item_desc.S",
                                    "item_effort": "$item.item_effort.N",
                                    "item_pillar": "$item.item_pillar.S",
                                    "item_lense": "$item.item_lense.S",
                                    "item_hri": [
                                        #foreach($elem in $item.item_hri.L) 
                                            "$elem.S"
                                        #if($foreach.hasNext),#end
                                    #end
                                    ]                                
                                }  
                                #if($foreach.hasNext),#end
                            #end                                       
                        ]
                        '''
                    }                     
                ),
                __ERROR_INTEGRATION_RESPONSE_400,
                __ERROR_INTEGRATION_RESPONSE_500              
            ],
            request_templates= {
                'application/json': json.dumps({
                        "TableName": dynamodb_table.table_name
                    }),
            },
        ),
    )

    success_response_200 = apigateway.MethodResponse(
        status_code='200',
        response_models={ "application/json": response_model}, 
        response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }
    )

    request_parameters = { 
        'method.request.querystring.lense': False, 
        'method.request.querystring.pillar': False 
    }

    resource.add_method(
        'GET', 
        integration=get_integration, 
        method_responses=[
            success_response_200,
            __ERROR_METHOD_RESPONSE_400, 
            __ERROR_METHOD_RESPONSE_500
        ],
        request_validator=request_validator,
        request_parameters=request_parameters,
        authorizer=auth, 
        authorization_type=apigateway.AuthorizationType.COGNITO
    )

__create_model(rest_api_gateway, name, content, schema, description='')

Helper method to create a model.

Attributes:

Name	Type	Description
rest_api_gateway	aws_cdk.aws_apigateway.RestApi	API Gateway the request validator belongs to.
name	str	Name of the model.
content	str	Content of the schema, e.g. application/json
schema	aws_cdk.aws_apigateway.JsonSchema	Schema for the model.
description	Optional[str]	Description of the model.

Returns:

Type	Description
	aws_cdk.aws_apigateway.Model: The created model.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_model(rest_api_gateway: apigateway.RestApi, name: str, content: str, schema: apigateway.JsonSchema, description: Optional[str] = ""):
    """Helper method to create a model.

    Attributes:
        rest_api_gateway (aws_cdk.aws_apigateway.RestApi): API Gateway the request validator belongs to.
        name (str): Name of the model.
        content (str): Content of the schema, e.g. `application/json`
        schema (aws_cdk.aws_apigateway.JsonSchema): Schema for the model.
        description (Optional[str]): Description of the model.

    Returns:
        aws_cdk.aws_apigateway.Model: The created model.
    """

    model_id: str = "WaReviewTool" + name

    model = rest_api_gateway.add_model(
        model_id,
        content_type=content,
        description=description,
        model_name=name,
        schema=schema
    )

    return model

__create_post_item(ddb_role, dynamodb_pkey_id, dynamodb_table, resource, request_model, response_model, request_validator, auth)

Create the POST Remediation Item methods on the provided REST API Gateway Resource.

Creates a POST method on the /{model_name} resource to create a Remediation Item.

Attributes:

Name	Type	Description
ddb_role	aws_cdk.aws_iam.Role	The IAM Role to access the DB from the API Gateway.
dynamodb_pkey_id	str	DynamoDB Table primary key name.
dynamodb_table	aws_cdk.aws_dynamodb.Table	The DynamoDB Table.
resource	aws_cdk.aws_apigateway.Resource	API Gateway resource where the resources and methods should be created.
request_model	aws_cdk.aws_apigateway.Model	Model for the request validation.
response_model	aws_cdk.aws_apigateway.Model	Model for the response validation.
request_validator	aws_cdk.aws_apigateway.RequestValidator	Validator for the request.
auth	aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer	Authorization for the endpoint.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_post_item(
    ddb_role: Role, 
    dynamodb_pkey_id: str, 
    dynamodb_table: Table, 
    resource: apigateway.Resource, 
    request_model: apigateway.Model,
    response_model: apigateway.Model,
    request_validator: apigateway.RequestValidator, 
    auth: apigateway.CognitoUserPoolsAuthorizer
    ):
    """Create the POST Remediation Item methods on the provided REST API Gateway Resource.

    Creates a POST method on the `/{model_name}` resource to create a Remediation Item.

    Attributes:
        ddb_role (aws_cdk.aws_iam.Role): The IAM Role to access the DB from the API Gateway.
        dynamodb_pkey_id (str): DynamoDB Table primary key name.
        dynamodb_table (aws_cdk.aws_dynamodb.Table): The DynamoDB Table.
        resource (aws_cdk.aws_apigateway.Resource): API Gateway resource where the resources and methods should be created.
        request_model (aws_cdk.aws_apigateway.Model): Model for the request validation.
        response_model (aws_cdk.aws_apigateway.Model): Model for the response validation.
        request_validator (aws_cdk.aws_apigateway.RequestValidator): Validator for the request.
        auth (aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer): Authorization for the endpoint.
    """

    post_integration = apigateway.AwsIntegration(
        service="dynamodb",
        action="PutItem",
        options=apigateway.IntegrationOptions(
            credentials_role=ddb_role,
            integration_responses=[
                apigateway.IntegrationResponse(
                    status_code="200",
                    selection_pattern="200",
                    response_parameters={
                        "method.response.header.Access-Control-Allow-Origin": "'*'"
                    },                      
                    response_templates= {
                        "application/json": '{ "requestId": "$context.requestId" }'
                    }
                ),
                __ERROR_INTEGRATION_RESPONSE_400,
                __ERROR_INTEGRATION_RESPONSE_500
            ],
            request_templates= {
                'application/json': '''
                    {
                        "Item": {
                            "%s": {
                                "S": "$context.requestId"
                            },
                            "item_title": { "S": "$input.path('$.item_title')" },
                            "item_effort": { "N": "$input.path('$.item_effort')"  },
                            "item_desc": { "S": "$input.path('$.item_desc')" },
                            "item_pillar": { "S": "$input.path('$.item_pillar')" },
                            "item_lense": { "S": "$input.path('$.item_lense')" },
                            "item_hri": { "L": [
                                #foreach($elem in $input.path('$.item_hri'))
                                     { "S" : "$elem" }
                                #if($foreach.hasNext),#end
                            #end
                            ] }
                        },
                        "TableName": "%s"
                    }
                ''' % (dynamodb_pkey_id, dynamodb_table.table_name)
            },
        ),
    )

    success_response_200 = apigateway.MethodResponse(
        status_code='200',
        response_models={ "application/json": response_model }, 
        response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }
    )

    resource.add_method(
        'POST', 
        integration=post_integration, 
        method_responses=[
            success_response_200,
            __ERROR_METHOD_RESPONSE_400, 
            __ERROR_METHOD_RESPONSE_500
        ],
        request_validator=request_validator,
        request_models={ "application/json": request_model }, 
        authorizer=auth, 
        authorization_type=apigateway.AuthorizationType.COGNITO
    )

__create_put_item(ddb_role, dynamodb_pkey_id, dynamodb_table, resource, request_model, response_model, request_validator, auth)

Create the PUT Remediation Item methods on the provided REST API Gateway Resource.

Creates a PUT method on the /{model_name}/{id} resource to update a single Remediation Item in the DynamoDB.

Attributes:

Name	Type	Description
ddb_role	aws_cdk.aws_iam.Role	The IAM Role to access the DB from the API Gateway.
dynamodb_pkey_id	str	DynamoDB Table primary key name.
dynamodb_table	aws_cdk.aws_dynamodb.Table	The DynamoDB Table.
resource	aws_cdk.aws_apigateway.Resource	API Gateway resource where the resources and methods should be created.
request_model	aws_cdk.aws_apigateway.Model	Model for the request validation.
response_model	aws_cdk.aws_apigateway.Model	Model for the response validation.
request_validator	aws_cdk.aws_apigateway.RequestValidator	Validator for the request.
auth	aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer	Authorization for the endpoint.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_put_item(
    ddb_role: Role, 
    dynamodb_pkey_id: str, 
    dynamodb_table: Table, 
    resource: apigateway.Resource, 
    request_model: apigateway.Model, 
    response_model: apigateway.Model,
    request_validator: apigateway.RequestValidator, 
    auth: apigateway.CognitoUserPoolsAuthorizer
    ):
    """Create the PUT Remediation Item methods on the provided REST API Gateway Resource.

    Creates a PUT method on the `/{model_name}/{id}` resource to update a single Remediation Item in the DynamoDB.

    Attributes:
        ddb_role (aws_cdk.aws_iam.Role): The IAM Role to access the DB from the API Gateway.
        dynamodb_pkey_id (str): DynamoDB Table primary key name.
        dynamodb_table (aws_cdk.aws_dynamodb.Table): The DynamoDB Table.
        resource (aws_cdk.aws_apigateway.Resource): API Gateway resource where the resources and methods should be created.
        request_model (aws_cdk.aws_apigateway.Model): Model for the request validation.
        response_model (aws_cdk.aws_apigateway.Model): Model for the response validation.
        request_validator (aws_cdk.aws_apigateway.RequestValidator): Validator for the request.
        auth (aws_cdk.aws_apigateway.CognitoUserPoolsAuthorizer): Authorization for the endpoint.
    """

    put_integration = apigateway.AwsIntegration(
        service="dynamodb",
        action="PutItem",
        options= apigateway.IntegrationOptions(
            credentials_role=ddb_role,
            integration_responses=[
                apigateway.IntegrationResponse(
                    status_code="200",
                    selection_pattern="200",
                    response_parameters={
                        "method.response.header.Access-Control-Allow-Origin": "'*'"
                    },                      
                ),
                __ERROR_INTEGRATION_RESPONSE_400,
                __ERROR_INTEGRATION_RESPONSE_500
            ],
            passthrough_behavior=apigateway.PassthroughBehavior.NEVER,
            request_templates= {
                'application/json': '''
                    {
                        "Item": {
                            "%s": {
                                "S": "$method.request.path.id"
                            },
                            "item_title": { "S": "$input.path('$.item_title')" },
                            "item_effort": { "N": "$input.path('$.item_effort')"  },
                            "item_desc": { "S": "$input.path('$.item_desc')" },
                            "item_pillar": { "S": "$input.path('$.item_pillar')" },
                            "item_lense": { "S": "$input.path('$.item_lense')" },                            
                            "item_hri": { "L": [
                                #foreach($elem in $input.path('$.item_hri'))
                                     { "S" : "$elem" }
                                #if($foreach.hasNext),#end
                            #end
                            ] }
                        },
                        "TableName": "%s"
                    }
                ''' % (dynamodb_pkey_id, dynamodb_table.table_name)
            },
        ),
    )

    success_response_200 = apigateway.MethodResponse(
        status_code='200',
        response_models={ "application/json": response_model}, 
        response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }
    )

    resource.add_method(
        'PUT', 
        integration=put_integration, 
        method_responses=[
            success_response_200,
            __ERROR_METHOD_RESPONSE_400, 
            __ERROR_METHOD_RESPONSE_500
        ],
        request_validator=request_validator,
        request_models={ "application/json": request_model }, 
        authorizer=auth, 
        authorization_type=apigateway.AuthorizationType.COGNITO
    )

__create_request_validator(stack, rest_api_gateway, name)

Helper method to create a request validator.

Attributes:

Name	Type	Description
stack	aws_cdk.aws_core.Stack	AWS CDK Stack to which it is deployed.
rest_api_gateway	aws_cdk.aws_apigateway.RestApi	API Gateway the request validator belongs to.
name	str	Name of the request validator.

Returns:

Type	Description
apigateway.RequestValidator	aws_cdk.aws_apigateway.RequestValidator: The created request validator.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def __create_request_validator(stack: core.Stack, rest_api_gateway: apigateway.RestApi, name: str) -> apigateway.RequestValidator:
    """Helper method to create a request validator.

    Attributes:
        stack (aws_cdk.aws_core.Stack): AWS CDK Stack to which it is deployed.
        rest_api_gateway (aws_cdk.aws_apigateway.RestApi): API Gateway the request validator belongs to.
        name (str): Name of the request validator.

    Returns:
        aws_cdk.aws_apigateway.RequestValidator: The created request validator.
    """

    request_validator_id = "WaReview" + name + "RequestValidator"

    request_validator = apigateway.RequestValidator(
            stack,
            request_validator_id,
            rest_api=rest_api_gateway, 
            validate_request_body=True,
            validate_request_parameters=False
        )    
    return request_validator

create(stack, rest_api_gateway, dynamodb_table_arn, auth, dynamodb_pkey_id='item_id', model_name='item')

Create the API resource and methods on the provided REST API Gateway.

Attributes:

Name	Type	Description
stack	aws_cdk.core.Stack	CDK Stack.
rest_api_gateway	aws_cdk.aws_apigateway.RestApi	Rest API to add to.
dynamodb_table_arn	str	ARN of the DynamoDB Tabkle containing the Remediation Items.
auth	aws_cdk.aws_cognito.CognitoUserPoolsAuthorizer	Cognito User Pool Authorizer used for the endpoint authentication.
dynamodb_pkey_id	Optional[str]	Primary Key of the DynamoDB Table, default item_id.
model_name	Optional[str]	The path for the resources, default item.

Source code in infrastructure/stacks/resources/api_gateway/resources/items.py

def create(
    stack: core.Stack, 
    rest_api_gateway: apigateway.RestApi, 
    dynamodb_table_arn: str, 
    auth: apigateway.CognitoUserPoolsAuthorizer,
    dynamodb_pkey_id: str = "item_id", 
    model_name: str = "item") -> None:
    """Create the API resource and methods on the provided REST API Gateway.

    Attributes:
        stack (aws_cdk.core.Stack): CDK Stack.        
        rest_api_gateway (aws_cdk.aws_apigateway.RestApi): Rest API to add to.
        dynamodb_table_arn (str): ARN of the DynamoDB Tabkle containing the Remediation Items.
        auth (aws_cdk.aws_cognito.CognitoUserPoolsAuthorizer): Cognito User Pool Authorizer used for the endpoint authentication.
        dynamodb_pkey_id (Optional[str]): Primary Key of the DynamoDB Table, default `item_id`.
        model_name (Optional[str]): The path for the resources, default `item`.

    """

    dynamodb_table = Table.from_table_arn(stack, "WaReviewToolRemediationItemDynamoDbTable", dynamodb_table_arn)

    ddb_write_role = create_integration_iam_role(stack, ["dynamodb:PutItem"], [dynamodb_table_arn], "WaReviewToolRemediationItemsDynamoDbPut")
    ddb_get_role = create_integration_iam_role(stack, ["dynamodb:GetItem", "dynamodb:Scan"], [dynamodb_table_arn], "WaReviewToolRemediationItemsDynamoDbGet")
    ddb_delete_role = create_integration_iam_role(stack, ["dynamodb:DeleteItem"], [dynamodb_table_arn], "WaReviewToolRemediationItemsDynamoDbDelete")

    ##########
    # Models
    ##########

    get_item_response_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.OBJECT,
        required=["item_id", "item_title", "item_effort", "item_desc", "item_hri", "item_lense", "item_pillar"],
        properties={
            "item_id": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                pattern="^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{10,14})$"
                ),
            "item_title": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                min_length=4,
                max_length=128,
                pattern="^([a-zA-Z0-9- _\.&!#=()\s]){0,}$"
                ),
            "item_effort": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.NUMBER,
                enum=[ 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0 ],
                default=0.25
            ),
            "item_desc": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_hri": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.ARRAY,
                items=apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING)
            ),
            "item_lense": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_pillar": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),

        }
    )

    get_item_response_model = __create_model(rest_api_gateway=rest_api_gateway, name="GetItemResponseModel", content="application/json", schema=get_item_response_model_schema, description="Validate the response body")    

    get_items_response_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.ARRAY,
        items=get_item_response_model_schema
    )

    get_items_response_model = __create_model(rest_api_gateway=rest_api_gateway, name="GetItemsResponseModel", content="application/json", schema=get_items_response_model_schema, description="Validate the response body")    

    post_question_update_request_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.OBJECT,
        required=[ "item_title", "item_effort", "item_desc", "item_hri", "item_lense", "item_pillar"],
        properties={
            "item_id": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                pattern="^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{10,14})$"
                ),
            "item_title": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                min_length=4,
                max_length=128,
                pattern="^([a-zA-Z0-9- _\.&!#=()\s]){0,}$"
                ),
            "item_effort": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.NUMBER,
                enum=[ 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0 ],
                default=0.25
            ),
            "item_desc": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_hri": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.ARRAY,
                items=apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING)
            ),
            "item_lense": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_pillar": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),            
        }
    )

    post_question_update_response_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.OBJECT
    )

    post_item_request_model = __create_model(rest_api_gateway=rest_api_gateway, name="PostItemRequestModel", content="application/json", schema=post_question_update_request_model_schema, description="Validate the request body")    
    post_item_response_model = __create_model(rest_api_gateway=rest_api_gateway, name="PostItemResponseModel", content="application/json", schema=post_question_update_response_model_schema, description="Validate the response body")    


    put_question_update_request_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.OBJECT,
        required=["item_title", "item_effort", "item_desc", "item_hri", "item_lense", "item_pillar"],
        properties={
            "item_id": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                pattern="^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{10,14})$"
                ),
            "item_title": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.STRING,
                min_length=4,
                max_length=128,
                pattern="^([a-zA-Z0-9- _\.&!#=()\s]){0,}$"
                ),
            "item_effort": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.NUMBER,
                enum=[ 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0 ],
                default=0.25
            ),
            "item_desc": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_hri": apigateway.JsonSchema(
                type=apigateway.JsonSchemaType.ARRAY,
                items=apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING)
            ),
            "item_lense": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),
            "item_pillar": apigateway.JsonSchema(type=apigateway.JsonSchemaType.STRING),            
        }
    )

    put_question_update_response_model_schema = apigateway.JsonSchema(
        type=apigateway.JsonSchemaType.OBJECT
    )

    put_item_request_model = __create_model(rest_api_gateway=rest_api_gateway, name="PutItemRequestModel", content="application/json", schema=put_question_update_request_model_schema, description="Validate the request body")    
    put_item_response_model = __create_model(rest_api_gateway=rest_api_gateway, name="PutItemResponseModel", content="application/json", schema=put_question_update_response_model_schema, description="Validate the response body")    

    delete_item_request_model = __create_model(rest_api_gateway=rest_api_gateway, name="DeleteItemRequestModel", content="application/json", schema=apigateway.JsonSchema(type=apigateway.JsonSchemaType.NULL), description="Validate the Request body")    
    delete_item_response_model = __create_model(rest_api_gateway=rest_api_gateway, name="DeleteItemResponseModel", content="application/json", schema=apigateway.JsonSchema(type=apigateway.JsonSchemaType.OBJECT,properties={}), description="Validate the Response body")    


    #
    ## Resources and Methods
    #

    items_resource = rest_api_gateway.root.add_resource(model_name.lower())

    request_validator = __create_request_validator(stack=stack, rest_api_gateway=rest_api_gateway, name="Item")
    __create_get_items(ddb_role=ddb_get_role, dynamodb_table=dynamodb_table, resource=items_resource, response_model=get_items_response_model, request_validator=request_validator, auth=auth)

    __create_post_item(ddb_role=ddb_write_role, dynamodb_pkey_id=dynamodb_pkey_id, dynamodb_table=dynamodb_table, resource=items_resource, request_model=post_item_request_model, response_model=post_item_response_model, request_validator=request_validator, auth=auth)

    item_resource = items_resource.add_resource('{id}')
    __create_get_item(ddb_role=ddb_get_role, dynamodb_pkey_id=dynamodb_pkey_id, dynamodb_table=dynamodb_table, resource=item_resource, response_model=get_item_response_model, request_validator=request_validator, auth=auth)

    __create_put_item(ddb_role=ddb_write_role, dynamodb_pkey_id=dynamodb_pkey_id, dynamodb_table=dynamodb_table, resource=item_resource, request_model=put_item_request_model, response_model=put_item_response_model, request_validator=request_validator, auth=auth)

    __create_delete_item(ddb_role=ddb_delete_role, dynamodb_pkey_id=dynamodb_pkey_id, dynamodb_table=dynamodb_table, resource=item_resource, response_model=delete_item_response_model, request_validator=request_validator, auth=auth)