PORTAL INTERNO MSS

Empower Your Projects with port_mss_action: Streamline, Secure, and Scale!

Table of Contents

• Overview
• Features
• Project Structure
  • Project Index
• Getting Started
  • Prerequisites
  • Installation
  • Usage
  • Testing
• Contributing
• License
• Acknowledgments
• Contributors
• Especial Thanks

---

Overview

The Portal Interno MSS project streamlines Infrastructure as Code (IaC) development by automating AWS CDK deployment, managing dependencies, and simplifying testing workflows. Key features include dynamic environment-based deployment, seamless integration with AWS services, and efficient testing setups. Ideal for IaC developers and teams seeking streamlined deployment and testing processes.

---

Features

	Feature	Summary
⚙️	Architecture	Fact 1 Fact 2 Fact 3
🔩	Code Quality	Fact 1 Fact 2 Fact 3
📄	Documentation	Primary Language: Python Language Counts: txt - 3, py - 116, bat - 1, json - 1, yml - 5 Package Managers: pip - requirements-dev.txt, iac/requirements.txt, iac/requirements-dev.txt
🔌	Integrations	Dependencies: github_actions, docker, pip, repo_owner.yml, create_pr.yml, docker-compose.yml, cdk.json, source.bat, requirements-dev.txt, python, ci.yml, cd.yml, requirements.txt, pytest-cov, boto3, python-dotenv, pytest
🧩	Modularity	Fact 1 Fact 2 Fact 3
🧪	Testing	Test Commands: Using pip - pytest
⚡️	Performance	Fact 1 Fact 2 Fact 3
🛡️	Security	Fact 1 Fact 2 Fact 3
📦	Dependencies	Fact 1 Fact 2 Fact 3
🚀	Scalability	Fact 1 Fact 2 Fact 3

---

Project Structure

└── port_mss_action/
    ├── .github
    │   └── workflows
    ├── README.md
    ├── iac
    │   ├── .gitignore
    │   ├── README.md
    │   ├── __init__.py
    │   ├── adjust_layer_directory.py
    │   ├── app.py
    │   ├── cdk.json
    │   ├── iac
    │   ├── local
    │   ├── requirements-dev.txt
    │   ├── requirements.txt
    │   └── source.bat
    ├── requirements-dev.txt
    ├── src
    │   ├── __init__.py
    │   ├── modules
    │   └── shared
    └── tests
        ├── __init__.py
        ├── modules
        └── shared

Project Index

PORT_MSS_ACTION/

__root__

requirements-dev.txt

- Facilitates testing and development by specifying required dependencies - Ensures seamless integration of pytest, pytest-cov, boto3, and python-dotenv for efficient testing and development workflows within the project architecture.

iac

app.py	- Orchestrates AWS CDK deployment based on environment variables, adjusting layer directories for Lambda functions - Determines deployment stage based on GitHub branch name and sets relevant tags - Creates an AWS CloudFormation stack with specified configurations and tags.
requirements.txt	Define dependencies for AWS CDK and Constructs library in the requirements file to manage infrastructure as code for the project.
source.bat	- Enables activation of a Python virtualenv on Windows by running a batch script - Simplifies the process and eliminates the need for separate documentation on Windows-specific virtualenv activation commands.
cdk.json	Enables configuration settings for AWS CDK, ensuring secure and efficient deployment across AWS and AWS China regions.
requirements-dev.txt	Define testing dependencies for the infrastructure as code project.
adjust_layer_directory.py	- The code file `adjust_layer_directory.py` facilitates adjusting the directory structure for Infrastructure as Code (IaC) projects - It handles copying shared directories to a specified destination, ensuring the correct structure for Lambda layers - This functionality streamlines the organization and deployment of resources within the project architecture.

local

docker-compose.yml

Facilitates local DynamoDB setup for development environment using Docker Compose.

iac

bucket_stack.py	- Defines AWS S3 buckets and CloudFront distributions for member and project photos based on the environment - Manages access policies and caching strategies for secure and optimized content delivery.
dynamo_stack.py	- Creates DynamoDB tables with specified attributes, indexes, and removal policies based on the environment - Exports removal policies for actions and members with dynamic names.
lambda_stack.py	- Generates Lambda functions for API Gateway integration, handling various CRUD operations for projects, members, and actions - Manages permissions for DynamoDB, SES, and S3 based on function requirements within the project's serverless architecture.
iac_stack.py	- Defines infrastructure for a REST API with AWS services like Cognito, DynamoDB, S3, and Lambda functions - Manages environment variables, CORS settings, and permissions for various functions - Integrates user authentication and authorization using Cognito User Pools.

src

modules

delete_action

app

delete_action_controller.py	- Handles the deletion of an action by validating parameters, processing the request, and returning the appropriate response based on the outcome - The controller interacts with the use case to delete the action, constructs a view model, and responds with success or error messages as needed.
delete_action_presenter.py	- Implements a Lambda handler for deleting actions, integrating with controllers and use cases - Retrieves repositories for actions and members from the environment - Parses incoming Lambda request data and processes it through the delete action controller, returning a formatted Lambda response.
delete_action_viewmodel.py	Defines view models for actions and deletion actions, facilitating data transformation for the frontend.
delete_action_usecase.py	- Implements the Delete Action Usecase, handling the deletion of an action based on user permissions and ownership - Validates user registration, active status, and authorization to delete the action - Ensures only the action owner or an admin can perform the deletion operation.

create_member

app

create_member_presenter.py	- Generates Lambda HTTP responses for creating a new member in the system - Orchestrates the flow between the HTTP request, member creation use case, and controller - Handles the event data and context to process the request and return the appropriate response.
create_member_controller.py	- Handles the creation of a new member by validating and processing incoming data - If all required parameters are present and valid, it creates a new member entity, generates a view model, and returns a successful response - Handles various error scenarios gracefully, providing appropriate error messages for missing parameters, duplicate items, and other issues.
create_member_usecase.py	- Implements a use case to create a new member in the system, ensuring uniqueness of user ID - Converts member details to title case and timestamps the hiring date.
create_member_viewmodel.py	- Transforms member data into a structured dictionary for creating a new member - The code encapsulates the member details and generates a formatted output for the creation process, ensuring consistency and ease of use within the project architecture.

delete_project

app

delete_project_viewmodel.py	- The `delete_project_viewmodel.py` file defines classes to represent and serialize project data for deletion - It encapsulates project details and formats them into a dictionary for deletion confirmation messages - This file plays a crucial role in managing project data during deletion operations within the codebase architecture.
delete_project_controller.py	- Handles the deletion of a project by validating parameters, executing the deletion process, and returning the appropriate response based on the outcome - The controller interacts with the use case to delete the project, constructs a view model, and responds with success or error messages as needed.
delete_project_usecase.py	- Implements a use case to delete a project, ensuring the user has the necessary permissions and the project exists - It interacts with repositories to handle the deletion process securely within the project architecture.
delete_project_presenter.py	- Handles the deletion of projects by orchestrating the communication between the controller and use case - Retrieves necessary data from the request, processes the deletion, and constructs the appropriate response for the Lambda function.

update_action

app

update_action_presenter.py	- Handles HTTP requests to update actions by interfacing with repositories and executing the necessary business logic through a controller - The code orchestrates the flow by processing incoming data, invoking the appropriate use case, and generating a response for the client.
update_action_viewmodel.py	- UpdateActionViewModel encapsulates the logic to transform an Action object into a dictionary representation for updating actions - It serves as a bridge between the Action entity and the presentation layer, ensuring a clean separation of concerns within the codebase architecture.
update_action_usecase.py	- Implements the Update Action Usecase, handling updates to action details based on specified parameters - Validates user permissions and ensures data integrity by updating associated members and start date accordingly.
update_action_controller.py	- Handles updating action details based on user input, validating and processing data to create a new action entity - Utilizes a structured approach to ensure data integrity and consistency, returning a view model with the updated action information - Handles various error scenarios gracefully, providing appropriate responses for different types of issues encountered during the update process.

get_history

app

get_history_presenter.py	- Handles the retrieval of historical data by orchestrating interactions between the controller, use case, and repositories - Parses incoming Lambda requests, enriches them with user information, and generates appropriate HTTP responses for the API endpoint.
get_history_viewmodel.py	- Generates a view model for historical actions, encapsulating user, time, and project details - Converts actions to dictionaries for easy serialization, including stack and action type tags - Handles pagination with a last evaluated key for efficient retrieval.
get_history_controller.py	- Handles retrieving user history based on specified parameters, validating input data, and returning the appropriate response - Parses and processes user requests, ensuring data integrity and error handling - The controller orchestrates the use case to fetch actions and generates a view model for the response, handling various exceptions for different scenarios.
get_history_usecase.py	- Implements a use case to retrieve user actions history, handling pagination and access control based on user roles - Validates user permissions and fetches relevant actions from repositories, ensuring data integrity and security within the codebase architecture.

create_action

app

create_action_viewmodel.py	- The code in create_action_viewmodel.py defines classes to represent and transform action data for creating new actions within the project architecture - It encapsulates the necessary attributes and methods to handle the conversion of action objects into dictionary formats for further processing and messaging purposes.
create_action_controller.py	- Handles the creation of actions by validating and processing incoming data, then invoking the appropriate use case to create the action - Returns a view model representing the created action in the response - Handles various error scenarios and maps them to the corresponding HTTP status codes for proper error handling.
create_action_presenter.py	- Facilitates the creation of actions by handling HTTP requests and responses through a structured flow of controller and use case interactions - Integrates with external interfaces and repositories to manage action and member data effectively within the project architecture.
create_action_usecase.py	- Implements a use case to create an action, ensuring user permissions and data integrity - Validates user registration, permission status, and creates associated actions - Manages action creation and association with members, enforcing project rules and maintaining data consistency.

get_all_projects

app

get_all_projects_presenter.py	- Handles the retrieval of all projects by orchestrating the communication between the controller, use case, and repositories - Parses incoming Lambda requests, processes the data, and constructs the appropriate HTTP response for the client.
get_all_projects_controller.py	- Handles requests to retrieve projects based on specified dates and user, ensuring data integrity and user permissions - Parses request data, validates types, and triggers the use case to fetch projects - Converts project data into a view model for response - Handles various error scenarios gracefully, returning appropriate HTTP responses.
get_all_projects_viewmodel.py	- Transforms project data into a structured format for display - The code organizes project details into a view model hierarchy, facilitating easy retrieval and presentation of multiple projects.
get_all_projects_usecase.py	- Retrieve and enrich project data by fetching all projects within a specified timeframe - Validate user permissions and filter projects based on user roles - Calculate hours worked on each project and return the updated project list.

update_member

app

update_member_viewmodel.py	Transforms member data into a view-friendly format for updating, encapsulating necessary fields and metadata.
update_member_controller.py	- Handles updating member information based on incoming requests, ensuring data integrity and type validation - Utilizes a structured approach to validate and process various fields such as name, email, role, stack, year, and more - Returns appropriate responses for different error scenarios, maintaining robustness and reliability in the system.
update_member_presenter.py	- Handles updating member information by orchestrating the communication between the controller, use case, and repository - Retrieves the requester's user information from the event context and returns the response in a standardized format.
update_member_usecase.py	- Manages updating member details, ensuring data integrity and authorization - Validates and processes changes based on user roles and permissions - Handles exceptions and triggers email notifications for specific scenarios - Maintains consistency and security in member data modifications.

delete_member

app

delete_member_presenter.py	- Handles the deletion of a member by orchestrating the communication between the controller, use case, and repository - Parses incoming Lambda requests, processes the deletion operation, and constructs the appropriate Lambda response.
delete_member_viewmodel.py	- Transforms member data into a dictionary for deletion confirmation - The code encapsulates member details and generates a structured output with a deletion message.
delete_member_usecase.py	- Implements the deletion of a member from the system based on specified conditions, ensuring that only authorized users can perform this action - Handles scenarios where the user initiating the deletion is an admin or a regular user, safeguarding against unauthorized access.
delete_member_controller.py	- Handles the deletion of a member in the system by validating the request parameters, executing the deletion process, and returning the appropriate response based on the outcome - The controller interacts with the use case and view model to manage the deletion operation and provide feedback to the user.

update_action_validation

app

update_action_validation_viewmodel.py	- Facilitates updating action validation status with a structured view model - The code defines two classes to represent action validation data and its update, ensuring a clear separation of concerns within the codebase architecture.
update_action_validation_presenter.py	- Handles HTTP requests, enriches them with user data, and delegates to a controller for processing - Utilizes repositories to validate and update actions, ensuring proper authorization and data integrity within the project's architecture.
update_action_validation_controller.py	- Handles updating action validation status based on user input, ensuring required parameters are present - Converts data to appropriate formats, handles errors, and returns responses with corresponding HTTP status codes.
update_action_validation_usecase.py	- Validates and updates action items based on user permissions and validity status - Checks user roles and activity status before allowing updates - Sends email notifications for invalid actions to associated members.

create_project

app

create_project_controller.py	- Handles project creation requests by validating and processing incoming data, then invoking the appropriate use case to create a new project - If any required parameters are missing or errors occur during processing, it returns the corresponding HTTP error response.
create_project_presenter.py	- Facilitates project creation by orchestrating interactions between the controller, use case, and repositories - Handles Lambda requests, enriches data, and generates appropriate HTTP responses.
create_project_usecase.py	Generates unique project codes and creates new projects, ensuring user roles, permissions, and project uniqueness are validated before persisting data.
create_project_viewmodel.py	Transforms a Project into a formatted dictionary for display, encapsulating project details and creation message.

batch_get_member

app

batch_get_member_viewmodel.py	Transforms member data into a structured format for retrieval, enabling seamless integration with the project's architecture.
batch_get_member_usecase.py	- Implements a use case to retrieve multiple members by user IDs, ensuring they are active and registered - The code interacts with a member repository to fetch and validate member data, handling errors for unregistered users or inactive members.
batch_get_member_controller.py	- Handles batch retrieval of member data, validating user input and returning appropriate responses based on the outcome - Validates user IDs, processes the request, and constructs a view model for successful responses - Handles various error scenarios like missing parameters, wrong types, and unregistered users, ensuring proper HTTP status codes are returned.
batch_get_member_presenter.py	- Handles HTTP requests to retrieve member data by orchestrating the use case and controller components - Parses incoming data, processes it through the controller, and constructs an HTTP response for the client.

get_history_project

app

get_history_project_controller.py	- Handles retrieving project history based on specified parameters, validating input data, and returning the results in a structured format - The controller ensures proper user authentication, parameter validation, and error handling, providing a seamless interaction between the user interface and the project history retrieval logic.
get_history_project_viewmodel.py	- Define a view model that transforms actions into a structured dictionary for retrieving project history - The model encapsulates action details and handles conversion to a dictionary format, including associated members and tags.
get_history_project_presenter.py	- Handles the HTTP request for retrieving project history by orchestrating the interaction between the controller, use case, and repositories - Parses the incoming request, processes it through the use case, and constructs the appropriate HTTP response for the client.
get_history_project_usecase.py	- Implements a use case to retrieve project history, ensuring user permissions and pagination - Validates user access, retrieves actions based on role, and handles pagination for historical data retrieval.

get_member

app

get_member_controller.py	- Handles incoming requests, validates parameters, and retrieves member data using the GetMemberUsecase - Converts data into a view model and returns a response based on the outcome, such as OK, BadRequest, Forbidden, or InternalServerError, ensuring proper error handling and response generation in the application.
get_member_viewmodel.py	Transforms member data into a structured dictionary for retrieval, maintaining key attributes and values.
get_member_usecase.py	- Retrieve member data, calculate hours worked, and assign projects based on user activity within specified date range - Validates user ID, checks registration status, and ensures user is active before returning member details.
get_member_presenter.py	- Facilitates retrieving member data by orchestrating interactions between the member repository, action repository, and the use case - The presenter handles incoming HTTP requests, enriches them with user context, and delegates processing to the controller for generating an appropriate HTTP response.

get_project

app

get_project_presenter.py	- Handles the retrieval of project data by orchestrating interactions between the project controller, use case, and repositories - Parses incoming HTTP requests, extracts user information, and generates appropriate HTTP responses for the project retrieval operation.
get_project_usecase.py	- Retrieves project details based on a provided code and user ID, ensuring the user is registered and active - Validates input parameters and handles potential errors, returning the project information if found.
get_project_viewmodel.py	Transforms project data into a structured view for retrieval, encapsulating key project details.
get_project_controller.py	- Handles incoming requests to retrieve project details, ensuring required parameters are present and valid - Utilizes a use case to fetch project data and constructs a view model for response - Handles various error scenarios and returns appropriate HTTP responses based on the outcome.

get_all_members

app

get_all_members_usecase.py	- Retrieves and processes member data based on specified criteria, including active status and admin role validation - Calculates hours worked and assigns projects to members - Ensures user permissions are met before returning the member data.
get_all_members_viewmodel.py	Converts and structures member data for retrieval, ensuring consistency and ease of use across the codebase architecture.
get_all_members_controller.py	- Handles requests to retrieve all members, validating parameters and handling errors appropriately - Utilizes a use case to fetch members based on the requester's user ID, then formats the data using a view model before returning a response with the member information.
get_all_members_presenter.py	- Handles HTTP requests to retrieve all members by utilizing a controller that interacts with a use case - The use case accesses member and action repositories to fetch the required data - The presenter formats the response for the Lambda function, ensuring seamless communication between the client and the backend system.

update_project

app

update_project_controller.py	- Handles updating project details based on user input, validating and processing data to ensure accuracy - Utilizes a structured approach to manage project information, interacting with external interfaces for seamless integration - Returns appropriate responses for successful updates or error scenarios, maintaining data integrity throughout the process.
update_project_presenter.py	- Handles updating project data by orchestrating interactions between the project repository, use case, and controller - Parses incoming HTTP requests, extracts user information, and generates appropriate HTTP responses.
update_project_viewmodel.py	- UpdateProjectViewmodel class transforms and structures project data for updates - It encapsulates the logic to convert project details into a dictionary format, including a message indicating successful project updates.
update_project_usecase.py	- UpdateProjectUsecase class handles updating project details based on user input - It validates user permissions, project existence, and member associations before making updates through repositories - This code ensures data integrity and security within the project architecture.

get_all_members_admin

app

get_all_members_admin_presenter.py	- Handles the Lambda function for retrieving all members in the admin panel by orchestrating the necessary components like controllers, use cases, and repositories - The code integrates with external interfaces for HTTP requests and responses, ensuring seamless communication within the project architecture.
get_all_members_admin_controller.py	Handles requests to retrieve all members for admin view, validating parameters and returning appropriate responses based on the outcome.
get_all_members_admin_usecase.py	- Generates a list of active members, their hours worked, and associated projects within a specified date range - Validates user permissions and handles edge cases like no active members or empty results - Integrates with repositories to fetch member and action data for comprehensive reporting.
get_all_members_admin_viewmodel.py	- Transforms member data into a structured format for admin display - The code organizes member details and formats them into dictionaries for easy retrieval and presentation.

shared

environments.py

- Defines environment variables and repositories based on the application stage - Determines repository implementations for actions and members - Handles loading environment variables and configuring local settings - Provides methods to retrieve environment settings and repositories.

domain

entities

member.py	Defines a Member entity with essential attributes and validation methods to ensure data integrity and consistency within the project's domain model.
action.py	- Defines a structured entity for actions within the project, enforcing data integrity and consistency - Validates and stores essential details such as user ID, dates, duration, and project information - Implements methods to ensure the correctness of action attributes like titles, descriptions, and associated members.
associated_action.py	- Defines an entity for an associated action with validation checks for action ID, start date, and user ID - The class ensures data integrity and consistency for associated actions within the project's domain entities.
project.py	- Defines a Project entity with attributes like code, name, and description - Validates user IDs and project code length - Allows changing Product Owner and Scrum Master user IDs - Handles photo validation and provides methods for comparison and representation.

repositories

member_repository_interface.py	- Defines an interface for member repository operations, including creating, deleting, updating, and retrieving members - Also supports batch operations and sending active member emails.
action_repository_interface.py	- Defines an interface for interacting with actions, projects, and associated actions - It outlines methods for creating, updating, and deleting actions and projects, as well as retrieving associated actions by user ID or project code - Additionally, it includes functionality for managing action durations and sending notifications.

enums

course_enum.py	Defines course enums for various engineering disciplines in the project's shared domain.
stack_enum.py	Defines stack categories for different project domains.
role_enum.py	Defines role enums for various team positions in the project's shared domain.
action_type_enum.py	Defines action types for various activities within the project, such as coding, meetings, code reviews, learning, presentations, design, architecture, and work.
active_enum.py	Defines active status states for the domain, such as ACTIVE, FREEZE, DISCONNECTED, and ON_HOLD.

infra

external

dynamo

dynamo_table.py

- Facilitates interaction with DynamoDB tables by managing the connection and providing access to the specified table - This class abstracts the setup and teardown logic required to work with DynamoDB, enhancing the codebase's modularity and maintainability.

datasources

dynamo_datasource.py	- The `dynamo_datasource.py` file in the project's architecture serves as a crucial component for interacting with DynamoDB tables - It encapsulates functionality for managing data sources, including defining the partition and sort keys - By leveraging the boto3 library, this code file enables seamless communication with DynamoDB tables, ensuring efficient data retrieval and manipulation within the system.
mock_db.py	Manages a list of classes for the DynamoDB mock database in the shared infrastructure.
manual_upload_database.py	- Improve data integrity by identifying and handling duplicates in the DynamoDB table - The code initializes a DynamoDB datasource, retrieves data, and performs a batch write operation - Additionally, it includes a function to identify duplicate records based on specified keys.

repositories

load_action_mock_to_dynamo.py	- Initialize and load mock data into DynamoDB for the project's action and project entities - The code sets up a DynamoDB table, then populates it with mock data for actions, projects, and associated actions - This process ensures a local DynamoDB instance is ready for testing or a real DynamoDB instance for production use.
member_repository_mock.py	- Manages a mock repository for members, allowing creation, deletion, retrieval, and updating of member information - Implements methods to handle member data and send active member emails.
load_member_mock_to_dynamo.py	- Initialize and load mock data into a DynamoDB table for the project's member repository - The code sets up the DynamoDB table and populates it with mock member data using a DynamoDB client and repository classes - This process ensures the availability of test data for the member repository in a local or real DynamoDB environment.
action_repository_dynamo.py	- The code file `action_repository_dynamo.py` in the `src/shared/infra/repositories` directory serves as an implementation of the Action Repository Interface within the project architecture - It facilitates the interaction with a DynamoDB datasource to handle actions, associated actions, members, and projects - This file encapsulates the logic for storing and retrieving data related to actions, ensuring seamless communication with the underlying data storage while maintaining consistency with the project's domain entities.
member_repository_dynamo.py	- Manages member data in DynamoDB, including creation, retrieval, update, and deletion operations - Handles member photo uploads to S3 with presigned URLs - Sends email notifications for member activation - Implements methods for batch retrieval and updating member details.
action_repository_mock.py	- The code file `action_repository_mock.py` serves as a mock implementation of an action repository interface within the project's architecture - It defines data structures for projects, actions, and associated actions, mimicking the behavior of a real repository - This file plays a crucial role in providing a simulated environment for testing and development purposes, enabling seamless integration of actions within the project's ecosystem.

dto

associated_action_dynamo_dto.py	Converts data between AssociatedAction and DynamoDB formats, facilitating seamless interaction with the database layer.
member_dynamo_dto.py	- Defines a data transfer object (DTO) for a member entity, facilitating conversion to and from a DynamoDB-compatible format - Enables seamless interaction between the application's domain entities and the underlying data storage layer.
project_dynamo_dto.py	Converts project data between DynamoDB format and entity objects, facilitating seamless integration within the project architecture.
user_api_gateway_dto.py	Converts user data from the API Gateway to a standardized DTO object for seamless integration within the project's infrastructure.
action_dynamo_dto.py	- Defines a data transfer object (DTO) for actions in the project, facilitating conversion between different data representations - The DTO encapsulates essential action details and provides methods for conversion to and from DynamoDB-compatible formats - This abstraction streamlines data handling and ensures consistency across the system.

helpers

enum

http_status_code_enum.py

Defines HTTP status codes as an Enum for easy reference and consistency across the codebase.

errors

controller_errors.py	Define custom error classes for handling missing parameters, wrong type parameters, and wrong file types in the controller_errors module, enhancing error management in the project architecture.
base_error.py	Defines a base error class to handle custom error messages across the codebase architecture.
domain_errors.py	Define custom domain errors for better error handling in the project's shared helpers.
usecase_errors.py	- Define custom error classes for specific scenarios like no items found, duplicated items, forbidden actions, user permissions, and invalid pagination amounts - These classes enhance error handling and provide clear feedback within the codebase architecture.

external_interfaces

external_interface.py	- Defines abstract classes for request and response interfaces to standardize external interactions within the project architecture - This code file establishes a clear structure for handling data and status codes in external interfaces, promoting consistency and ease of integration across various components.
http_lambda_requests.py	- The code file in src/shared/helpers/external_interfaces/http_lambda_requests.py defines classes for handling HTTP requests and responses in a Lambda environment - It encapsulates logic for constructing and formatting HTTP responses, including setting default headers and handling request data - The classes provide a structured approach for managing communication with external interfaces in AWS Lambda functions.
http_models.py	- Defines HTTP request and response models with data, headers, and status code attributes - Handles overlapping keys between body, query parameters, and headers - Provides a structured representation of incoming and outgoing HTTP messages.
http_codes.py	- Define standard HTTP response classes for different status codes in the project's shared helpers - These classes encapsulate response logic for OK, Created, No Content, Bad Request, Internal Server Error, Not Found, Conflict, Redirect, and Forbidden responses, enhancing code readability and maintainability.

utils

compose_invalid_action_email.py	Generates an invalid action email message by composing a customized HTML template with member and action details.
compose_member_active_email.py	- Generates an HTML email message to notify a member of their system activation status - Incorporates member's name dynamically into the message template.

.github

workflows

REPO_OWNER.yml	- Implements a workflow that checks and approves the owner of a repository on pull request reviews for specified branches - It leverages a reusable CI workflow file from the `maua-dev/ci_workflows_reusable` repository to streamline the process.
CI.yml	- Automate CI/CD pipeline for testing and code coverage - Run tests, generate coverage reports, and upload to Codecov using GitHub Actions - Ensure Python 3.9 setup and dependencies installation before executing tests - This workflow triggers on push, pull requests, and manual dispatch.
CREATE_PR.yml	- Automates the creation of pull requests on specific branches by leveraging a reusable workflow file - This setup streamlines the process of initiating code reviews and collaboration within the project, enhancing overall development efficiency and code quality.
CD.yml	Automates AWS CDK deployment based on branch pushes and workflow triggers, setting up AWS credentials and deploying infrastructure with specified configurations.

---

Getting Started

Prerequisites

Before getting started with port_mss_action, ensure your runtime environment meets the following requirements:

• Programming Language: Python
• Package Manager: Pip
• Container Runtime: Docker

Installation

Install port_mss_action using one of the following methods:

Build from source:

1. Clone the port_mss_action repository:

❯ git clone https://github.com/Maua-Dev/port_mss_action

2. Navigate to the project directory:

❯ cd port_mss_action

3. Install the project dependencies:

Using pip  

❯ pip install -r requirements-dev.txt, iac/requirements.txt, iac/requirements-dev.txt

Using docker  

❯ docker build -t Maua-Dev/port_mss_action .

Usage

Run port_mss_action using the following command: Using pip  

❯ python {entrypoint}

Using docker  

❯ docker run -it {image_name}

Testing

Run the test suite using the following command: Using pip  

❯ pytest

Contributing

• 💬 Join the Discussions: Share your insights, provide feedback, or ask questions.
• 🐛 Report Issues: Submit bugs found or log feature requests for the port_mss_action project.
• 💡 Submit Pull Requests: Review open PRs, and submit your own PRs.

Contributing Guidelines

1. Fork the Repository: Start by forking the project repository to your github account.
2. Clone Locally: Clone the forked repository to your local machine using a git client.

   git clone https://github.com/Maua-Dev/port_mss_action

3. Create a New Branch: Always work on a new branch, giving it a descriptive name.

   git checkout -b new-feature-x

4. Make Your Changes: Develop and test your changes locally.
5. Commit Your Changes: Commit with a clear message describing your updates.

   git commit -m 'Implemented new feature x.'

6. Push to github: Push the changes to your forked repository.

   git push origin new-feature-x

7. Submit a Pull Request: Create a PR against the original project repository. Clearly describe the changes and their motivations.
8. Review: Once your PR is reviewed and approved, it will be merged into the main branch. Congratulations on your contribution!

Contributor Graph

---

License

This project is protected under the MIT License.

---

Contributors

• Bruno Vilardi - Brvilardi 👷‍♂️
• Hector Guerrini - hectorguerrini 🧙‍♂️
• João Branco - JoaoVitorBranco 😎
• Vitor Soller - VgsStudio 🐱‍💻
• Luigi Trevisan - LuigiTrevisan 📺
• Mateus Capaldo - MatCMartins 🔥
• Rafael Rubio - Rubiozito 🐦
• Gabriel Bianconi - GabrielBianconiconi 🚨
• João Pedro Soares - joae1234 🖌️
• Rodrigo Morales - RodrigoM2004 🛞
• Lucas Crapino - LucasCrapino 🐼
• Rafael Ruthes - rruthes 🐨
• Thomas Boehm - ThomassBoehm 🏈
• Leonardo Moreno - pleomoreno ⚽
• Guilherme Guerreiro - GuiGuerreiroo ⚒️

Especial Thanks

• Dev. Community Mauá
• Clean Architecture: A Craftsman's Guide to Software Structure and Design
• Institute Mauá of Technology

---