danphenderson / baldin Goto Github PK

Update README.md.

• Address overview TODO
• Clean up reference bit
• Add appropriate badges to application

Make a Contributing.md, Security.md, LISCENCE.md and CITATION.cff.

Please describe.

To increase dev velocity, we will load applications and resumes into the database from the datalake.

The data lake structure is:

public/

• leads/
  • .json
  • enriched/
    • .json
• cover-letters/
  • .pdf
  • templates/
    • .pdf
• resumes/
  • .pdf
  • templates/
    • .pdf

Requirements

• Update the lead model to have a relationship to the User, and (data-orchestration endpoint will become authorized).
  • Refactor the logic; clean it up.
  • Look at the old job runner endpoint.
  • Update frontend to handle authorized requests.
• Implement an endpoint to load cover letters.
• Implement an endpoint to load resumes.

The application and resume file format will be pdf's.

In the future, this will be an admin service.

Use openapi.json to generate and admin interface.

reating a React-TypeScript admin interface based on your provided openapi.json involves several steps. The openapi.json file defines various API endpoints, request/response structures, and authentication mechanisms. Here's a high-level overview of how you could approach this task:

Parse the OpenAPI Specification:

Use a library like swagger-parser or openapi-typescript to parse the OpenAPI specification and generate TypeScript interfaces and types. This will ensure type safety and help with auto-completion in your IDE.
Setup React Project with TypeScript:

Create a new React project with TypeScript support. You can use Create React App with the TypeScript template for this.
Install necessary dependencies like react-router-dom for routing, axios or fetch for making API calls, and a UI library like Material-UI or Ant Design for pre-built components.
Design the Admin Interface:

Based on your API endpoints, design different pages/components for each major functionality (e.g., Authentication, User Management, Lead Management, ETL Event Management).
Implement forms for creating and updating resources, tables or lists for displaying data, and other UI elements as needed.
Implement API Services:

Create services to interact with the API. These services will use the generated types and interfaces from the OpenAPI specification.
Handle authentication (JWT tokens), request headers, and error handling in these services.
State Management:

Depending on the complexity of your admin interface, consider using state management libraries like Redux or Context API for managing global state (e.g., user authentication state).
Routing and Navigation:

Setup routing using react-router-dom. Protect certain routes (e.g., user management) and redirect based on user authentication status or role.
Testing and Validation:

Write unit tests for your components and services using a library like Jest or React Testing Library.
Validate forms based on the requirements in your OpenAPI specification.
Deployment and Environment Setup:

Set up different environments (development, staging, production) and configure environment variables.
Prepare the application for deployment on a hosting service or server.
Continuous Integration/Continuous Deployment (CI/CD):

Implement CI/CD pipelines for automated testing and deployment using tools like GitHub Actions, GitLab CI, or Jenkins.
Documentation and Maintenance:

Document the setup process, component usage, and any specific configurations.
Plan for regular maintenance and updates to keep the application secure and up to date with dependencies.
This outline provides a roadmap for building the React-TypeScript admin interface. Each step involves detailed implementation, which would depend on your specific requirements and the details of your openapi.json file.

f# OVERHAUL

Relocate the docker-compose.yml and .env files to the root of the repository. Run both the frontend and backend via docker, I.e. make the application portable. Ensure API proxy is correctly configured.

Use Arsenic web driver in replacement of selenium. This resolves the issue that the selenium API is blocking.

When a user registers, it should ask for information to build a comprehensive profile.

Update the API user router and model, and then make changes to the register component.

Dependent on API, wip.

Create an ETL orchestrator api.

This will create a few new models.

Create a GitHub Action for the backend CI workflow that runs pytest suite and lints code.

Integrate Alembic to handle API migrations.