This project demonstrates the interface between a fingerprint sensor and an Arduino Uno board. The system utilizes a 16×2 LCD to guide the user through the enrollment and scanning process. The fingerprint sensor is used for capturing and recognizing fingerprints.

• Project Components
• Getting Started
  • Prerequisites
  • Hardware Setup
  • Libraries
• Project Description
• Circuit Diagram
• YouTube Video
• Simulation

• Arduino Board Uno R3
• Finger Print Sensor (Adafruit Fingerprint Sensor)
• Liquid Crystal Display 16×2
• Connecting Wires

To run the code, you will need:

• Arduino IDE installed on your computer
• Arduino Uno board
• Adafruit Fingerprint Sensor Library (link to the library)
• Proteus installed in your system (simulation purpose)

• Adafruit Fingerprint Sensor Library
• LiquidCrystal Library

In this implementation of fingerprint sensor interface with Arduino Uno board. For input, I used Four push buttons. The menu on LCD guides the enrollment and scanning process.

https://youtu.be/Pv_ZpUe7_aw

To simulate the project on proteus please watch the youtube tutorial video.

An exercise to better understand the workings of blockchains and cryptocurrencies. Completely made with python and a sqlite3 database, implements the key features of a blockchain, such as:

• Distributable: every block must exist and be in its place in order for the chain to be healthy;
• Proof of Work: done by randomly chosen miners;
• Secure: PBKDF authentication, with the use of salts;
• Fast checking of chain integrity

Is Packaged with a custom CLI:

Blocks stored in the database contain the following nodes:

Made from scratch, implements the hash function, given a given the steps of the algorithm.

The logo, logged in user and options need to be redefined at every command.

Getters and setters were implemented. An example is the change in options when a user is authenticated (options like “send pisiticoins” are added) versus not authenticated ( options like “log in” are added).

Using pynput, creates a listener for keys such as arrows and enter. Although other, easier to implement, libraries exist, this was the only one that provided a solution supported in Windows and Linux. Compatibility is one of the goals of this project.

Re-renders the screen as soon as one of those is pressed.

The module OptionsMenu.py is a collection of functions wich need to communicate with each other.

As I didn’t want to define them with many arguments each, the first idea was to create global variables. This, however, is ill-advised in basically all the forums I researched.

The solution I came up with, then, was to use Environment variables. It works nicely, even though I it is not its intended use. One negative aspect is that they only accept strings. Therefore, the use of “true” and “false” were required.

In hindsight, a more elegant solution would be to simply wrap all of the function with a class. The required variables would, then, be accessible by every method. To kickstart the menu, the addition of a start() or begin() method that calls the others would suffice.

Two classes with multiple methods used to perform the various queries to the database required for the main program.

All of the communication with the sqlite db is done via these functions.

Therefore, the end user does not need to understand the underlying schema or implement custom queries.

They are devided into getters, setters and updaters.

An account id is derived using PBKDF2 with 10,000 rounds and 16 bytes long salts. Only such id is stored in the database.

Logging in repeats the process for every salt stored and matches its corresponding id.

Database is pre-populated accounts, whose passphrases are each one of the lower case letters from “a” to “m”.

Rehashes every block, in order, to determine inconsistencies.

Breaks chain integrity until fixing or remining of all blocks is executed.

Remines necessary blocks.

Remines every block and tries to figure out a non destructive way of fixing the chain.

Prompts the user for an account, then print its balance.

Requires user to be logged in and have a sufficiently large balance.

Pretty prints a blocks’s information.

Recalculates every user’s balance by going through every block, in order.

Recomended using a virtual environment.

Install dependencies

pip install -r requirements.txt

Run

python3 src/PisitiCoin.py. 

Create a new account or log in to one of the existing ones whose passphrases are each one of the lower case letters from “a” to “m”.

Comes with pre populated blockchain. Give it a try!

A modern, feature-rich e-commerce backend built with .NET Core 8.0, implementing clean architecture principles. This API provides comprehensive endpoints for product management, order processing, payment handling, and customer management, using PostgreSQL for data persistence.

• Features
• Architecture
• Tech Stack
• Getting Started
• API Documentation
• Contributing

• ✅ CRUD operations for products
• ✅ Product categorization and filtering
• ✅ Brand management
• ✅ Price and inventory tracking

• ✅ Order creation and management
• ✅ Order status tracking
• ✅ Multiple payment methods
• ✅ Order history

• ✅ Secure payment handling
• ✅ Multiple payment methods (Credit Card, PayPal, etc.)
• ✅ Payment status tracking
• ✅ Transaction history

• ✅ Customer profiles
• ✅ Order history
• ✅ Address management

• ✅ Stock level tracking
• ✅ Low stock alerts
• ✅ Stock updates
• ✅ Stock availability checks

RetailShop/
├── API/                  # Web API Layer
│   ├── Controllers/      # API endpoints
│   ├── DTOs/            # Data transfer objects
│   ├── Helpers/         # Utility classes
│   └── Middleware/      # Custom middleware
├── Core/                # Domain Layer
│   ├── Entities/        # Domain models
│   ├── Interfaces/      # Core abstractions
│   ├── Services/        # Domain services
│   └── Specifications/  # Query specifications
└── Infrastructure/      # Data Layer
    ├── Data/           # Database context
    ├── Repositories/   # Data access
    └── Services/       # External services

• 🏛️ Clean Architecture
• 📚 Repository Pattern
• 🔍 Specification Pattern
• ✨ SOLID Principles
• 🔄 DRY (Don’t Repeat Yourself)

Database schema showing relationships between core entities

High-level overview of the application’s data flow

Request/response flow for key operations

• ⚡ .NET Core 8.0
• 🗄️ Entity Framework Core 8.0
• 🐘 PostgreSQL
• 🔄 AutoMapper
• 📚 Swagger/OpenAPI

• .NET Core SDK 8.0
• PostgreSQL
• Visual Studio Code or Visual Studio 2022

1. Clone Repository

git clone https://github.com/Floyden-Monteiro/RetailShop.git
cd RetailShop

2. Configure Database

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=retailshop;Username=your_username;Password=your_password"
  }
}

3. Run Migrations

dotnet ef database update -p Infrastructure -s API

4. Start Application

cd API
dotnet run

• GET /api/products – List all products
• GET /api/products/{id} – Get product details
• POST /api/products – Create product
• PUT /api/products/{id} – Update product
• DELETE /api/products/{id} – Delete product

• GET /api/orders – List all orders
• GET /api/orders/{id} – Get order details
• POST /api/orders – Create order
• PUT /api/orders/{id}/status – Update status

• GET /api/payments – List all payments
• GET /api/payments/{id} – Get payment details
• POST /api/payments – Process payment
• GET /api/payments/order/{orderId} – Get order payment

• GET /api/customers – List all customers
• GET /api/customers/{id} – Get customer details
• POST /api/customers – Create customer
• PUT /api/customers/{id} – Update customer

• GET /api/inventory/low-stock – Check low stock
• PUT /api/inventory/update-stock/{id} – Update stock
• GET /api/inventory/check-stock/{id} – Check availability

Check Low Stock

GET /api/inventory/low-stock?threshold=5

Update Stock

PUT /api/inventory/update-stock/1
Content-Type: application/json

{
    "quantity": 100
}

Check Availability

GET /api/inventory/check-stock/1?quantity=5

1. Fork repository
2. Create feature branch (git checkout -b feature/NewFeature)
3. Commit changes (git commit -m 'Add NewFeature')
4. Push to branch (git push origin feature/NewFeature)
5. Open Pull Request

RubyMassMailer is a Rails API-only application designed to provide a flexible platform for sending mass transactional emails. Whether you’re sending order confirmations, password resets, or any other type of email, RubyMassMailer makes it easy to manage and send your emails.

• API-Only: Lightweight and efficient API-only Rails application.
• Mass Email Sending: Easily send transactional emails to multiple recipients.
• Customizable Templates: Use customizable email templates to fit your branding and message.
• Queue Processing: Background job processing for handling email queues.

• Ruby 3.0
• Rails 6.0 or higher

1. Clone the repository:

   git clone https://github.com/greeenboi/RubyMassMailer.git
   cd RubyMassMailer

2. Install the dependencies:

   bundle install

3. Create and Fill the Enviroment file .env.example -> .env

4. Start the server:

   rails s

Within ./config/initializers/mailjet adjust the api v3.1 or v3.0 depending on whether you want to send batch mails or not (check your mailjet config)

Configure the mailer settings in config/environments/production.rb:

config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
  address: ENV['SMTP_ADDRESS'],
  port: ENV['SMTP_PORT'],
  user_name: ENV['SMTP_USER_NAME'],
  password: ENV['SMTP_PASSWORD'],
  authentication: 'plain',
  enable_starttls_auto: true
}

Sending Emails
To send an email, make a POST request to the /api/v1/emails endpoint.

Sample JS script

const fs = require('fs');
const path = require('path');
const axios = require('axios');
const FormData = require('form-data');

const API_URL = 'http://localhost:3000/api/v1/emails'; 
const RECIPIENT_EMAIL = 'coolman@email.com'; // Replace with your test recipient email
const ATTACHMENT_PATH = './yummy.jpg'; // Replace with the path to a test attachment file

async function sendTestEmail() {
  try {
    const formData = new FormData();
    formData.append('email[to]', RECIPIENT_EMAIL);
    formData.append('email[to_name]', 'Test Recipient');
    formData.append('email[subject]', 'Test Email from Demo Server');
    formData.append('email[text_content]', 'This is a test email sent from our demo server.');
    formData.append('email[html_content]', '<h1>Test Email</h1><p>This is a <strong>test email</strong> sent from our demo server.</p>');

    // Add attachment if the file exists
    if (fs.existsSync(ATTACHMENT_PATH)) {
      const attachment = fs.createReadStream(ATTACHMENT_PATH);
      formData.append('email[attachments][]', attachment, path.basename(ATTACHMENT_PATH));
    }

    const response = await axios.post(API_URL, formData, {
      headers: {
        ...formData.getHeaders(),
      },
    });

    console.log('Response Status:', response.status);
    console.log('Response Data:', response.data);
  } catch (error) {
    console.error('Error sending email:', error.response ? error.response.data : error.message);
  }
}

sendTestEmail();

We will open this soon.

This project is licensed under the MIT License – see the LICENSE file for details.

This is a Javascript package for the Attack-Modifier of the boardgame Gloomhaven.

For this purpose each modifier card and each modifier deck is explicitely implemented.

This package includes a corresponding .png file for every single card.

The features folder contains the source code and pictures.

• Create every base modifier card
• Create every class modifier card

• Create player and monster modifier decks
• Create every class modifier deck
• Add or remove cards from the deck
• Shuffle the deck
• Draw a card from a deck with a given value
• Draw with advantage/disadvantage
• Look at the top X cards
• Look at the top X cards and put them back in any order
• Apply perks of a class

The __ tests __ folder contains the tests for the implemented features. Every implemented feature was tested seperately as well as within joined cases.

• All implemented cards
• All implemented decks and methods

// Create a card
const plusTwo = new PlusTwo

// Apply card modifier to a value
plusTwo.modifier(3) == 5

// Create a deck
var deck = new Deck

// Add a card to the deck (i.e. +2 card)
deck.addCard(plusTwo)

// Draw a card with a value (i.e. 4)
deck.draw(4)

// Modifier after drawing
deck.modifier == 4

// Value after drawing
deck.value == 6

// Special after drawing
deck.special = []

This project does not aim to be commercialized in any way. It is a personal project for learning purposes only.

• About
• Getting Started
• Usage

To get started with this project, you will need to follow the instructions below.

1. Have both Python 3.7 or higher and Jupiter Notebook installed.

2. Clone this repository using the following command:

   git clone https://github.com/dorian-roux/Formula1-analysis

3. Navigate to the repository and create virtual environment and activate it using the following commands:

   python -m venv ${YOUR_ENV_NAME}
   source ${YOUR_ENV_NAME}/bin/activate # For Linux

   You can replace ${YOUR_ENV_NAME} with the name you want to give to your virtual environment.

4. Install the required packages using the following command:

   pip install -r requirements.txt

After those steps, you should be able to run the Notebooks.

The Ergast Developer API. is used to get the data for this project. It is an experimental web service which provides a historical record of motor racing data for non-commercial purposes.

To generate the data files formula1-circuits.json and formula1-data.json, you need to run the Notebook DataF1-ErgastAPI.ipynb which will generate the data in their corresponding folder. Those data will be used in the analysis and visualization Notebooks.

The data file formula1-circuits.json will contain the following information about the circuits based on the CIRCUIT_ID :

• Circuit : The name of the circuit.
• Country : The country where the circuit is located.
• City : The city where the circuit is located.
• Coordinates : The coordinates of the circuit.

Example with the Silverstone circuit :

"silverstone": {
    "CIRCUIT_NAME": "Silverstone Circuit",
    "COUNTRY": "UK",
    "CITY": "Silverstone",
    "COORDINATES": ["52.0786", "-1.01694"]
},

the data file formula1-data.json will contain global information regarding Formula 1. It contains the racing information based on the YEAR:

• Drivers : Information about the drivers including their full name, birthdate and nationality.
• Constructors : Information about the constructors including their name and nationality.
• Circuits : Information about the circuits including their id, name and the date.
• Laps : Information about the laps including for each lap all the drivers position and time. The laps are not available for every year (most unlikely to be available for the early years).
• Results : Information about the results for each race including the driver, construction, grid position, final position, time, fastest lap and fastest lap ranking. The time of the driver is based on the time of the winner of the race (for instance D1 finished first in 1h30m00s and D2 finished second in 1h30m10s, D2 will have a time of +10s). Here also the availability of the fastest lap is not guaranteed for every year.

Welcome to TheMovie, an Android application that utilizes the JSONPlaceholder Database to retrieve posts and their comments, providing a social media app-like experience.

An Android app with modular architecture and MVVM architectural pattern.

Furthermore, some libraries and frameworks such as:

• Splash screen api and container HomeActivity.
• Network connectivity interceptor for HTTP requests.
• Hilt for dependencies injection.
• Room for local storage.
• Retrofit2 for API requests.
• Paging3 for local & remote data pagination.
• RemoteMediator for pagination orchestration.
• Coroutines and Flow for Reactive Functional Programming.
• StateFlow and SharedFlow for observing and updating data.
• ViewBinding for activities and fragments.
• Timber for logging purposes.
• Android Studio EditorConfig file to maintain consistent coding styles.
• Gradle’s Kotlin DSL.
• SonarCloud for static code analysis.
• SonarQube configuration files.
• JaCoCo maven plugin to generate test coverage reports.
• ktlint for static code analysis.
• LeakCanary for memory leaks detection.
• dokka for Kotlin’s documentation generation.

To summarize, every technology mentioned above was included in this project in order to meet the following requirements:

1. Load posts from JSON API, using both _start and _limit query parameters to support pagination (e.g. jsonplaceholder.typicode.com/posts?_start=0&_limit=10).
2. Show up swipe-to-options feature in posts recycler view items, allowing both delete a post and mark a post as favorite.
3. Favorite posts are shown up at the top of the list.
4. When a favorite post is unmarked as favorite, it returns to its previous position in the list.
5. Favorite posts have a star indicator.
6. Delete all posts in posts list except from the favorite ones using a floating button.
7. Fetching posts from JSON API when pull-to-refresh.
8. Post details screen is opened up when a post is tapped.
9. Delete a post and mark a post as favorite in post details screen.
10. Show up post, author, and comments data in post details screen.
11. App is able to work offline, loading both posts lists and posts details from local database.
12. Supporting landscape mode without losing screens’ state.

Clone this repository and import it into Android Studio

git clone https://github.com/JorgeDiazz/android-zemoga-tech-test.git  

Herein you can find multiple targets that the app takes into account:

Where the following formed variants are built for staging purposes:

• stagingInternalDebug
• stagingInternalRelease

And these ones for production purposes:

• productionInternalDebug
• productionInternalRelease
• productionExternalDebug
• productionExternalRelease

In order to sign your debug app build using debug-keystore.jks keystore, these are the credentials you will have to take in mind:

STORE_FILE = ./app/debug-keystore.jks

STORE_PASSWORD = android

KEY_ALIAS = android_zemoga

KEY_PASSWORD = android

1. Project’s CodeStyle can be found here.
2. Project utilities file can be found here.

Parti provides a simple, partitioned messaging framework across a cluster of nodes. Send a message for a given partition to any node in the cluster, and the message will be forwarded to the node that owns that partition. The cluster will automatically rebalance as nodes are added and removed. Under the hood, Parti uses hashicorp/raft to distribute work and manage membership.

# run node 1
make run1
# run node 2 (in another terminal)
make run2
# run node 3 (in another terminal)
make run3

# observe the partitions by asking node 1
go run ./client stats --addr 0.0.0.0:50101

# ping a partition from a given node
go run ./client ping --addr 0.0.0.0:50101 --partition 0
go run ./client ping --addr 0.0.0.0:50101 --partition 9

# send a message to various partitions and observe it forward
# curl 'localhost:50001/send?partition=9&message=msg2'
go run ./example send --partition 0 --addr 0.0.0.0:50001 hello world
# curl 'localhost:50001/send?partition=1&message=msg1'
go run ./example send --partition 9 --addr 0.0.0.0:50001 hello world

1. tell all nodes the pause the partition
2. confirm with prior owner that they have shut down (or confirm they are dead and not in the cluster)
3. inform all nodes of the new owner and that it’s started

• 📖 About the Project
  • 🛠 Built With
    • Tech Stack
    • Key Features
  • 🚀 Live Demo
• 👥 Authors
• 🤝 Contributing
• ⭐️ Show your support
• 🙏 Acknowledgements
• 📩 Support & Feedback
• 📝 License

“Quote-Generator is a website created using HTML, CSS, and JavaScript. This website is dedicated to generating quotes on demand, utilizing a Quotes API. I’m actively managing this project on GitHub and using Git for version control. Webpack is employed to streamline the build process, and code linters are in place to catch and rectify code errors. Feel free to explore the live demo provided in the README! 😊”

• [multi-page responsive website]
• [flex & grid]

(back to top)

Add a link to your deployed project.

• Live Demo Link

(back to top)

👤 Author1

• GitHub: @Ameer2000Mzori
• LinkedIn: Ameer Ameen

(back to top)

Contributions, issues, and feature requests are welcome! please dont forget to contact ameerapex496@gmail.com

Feel free to check the issues page.

(back to top)

If you like this project, don’t hesitate to give it a star 😊.

(back to top)

(back to top)

If you have any feedback, please reach out to me at ameerapex496@gmail.com 📨

(back to top)

This project is MIT licensed.

NOTE: we recommend using the MIT license – you can set it up quickly by using templates available on GitHub. You can also use any other license if you wish.

(back to top)

A program that sorts files based on various attributes from the windows context menu. Simply install the program and your context menu will have an added Sort Files entry.

Nothing complicated, it gets the job done.

The context menu is the option menu created from right clicking, such as:

First, install the pip package

pip install freshen-sorter

Install the dependencies:

pip install pyyaml
pip install context_menu

and run the following command to install to the context menu.

freshen -i

And you’re done!

To uninstall, simply run:

freshen -u

1. Download the latest release from the repository.

2. Unzip the folder to a location where it won’t be moved.

3. Run the reginstall.py file

Made to be simple! No complicated command lines needed.

1. Install the required files.
2. Right click on the background of any Directory
3. Go to the Sort Files option and selected the desired organizer.

There are four different options to organize files.

Probably the most useful organizer. Sorts each file into a folder based on the config/filegroups.yml file. The file already comes with the most common file extensions for each type of file(pictures, videos, etc.)

As mentioned earlier, the Sort by File Type uses the filegroups.yml to determine organization. This file can be manually changed to change the desired output, and the organization is quite straightforward.

# Audio Files
audio:
  - aif
  - cda
  - mid
  - midi
  - mp3
  - mpa
  - ogg
  - wav
  - wma
  - wpl
# Archive files
archives:
  - 7z
  - arj
  - deb
  - pkg
  - rar
  - rpm
  - tar.gz
  - z
  - zip
# etc.

You can either change the filegroups.yml file in the src directory and use the files built from the src folder, or if you already have the built files you can directly change the file in the dist directory. The context menu reads the file every time it is ran, so it will instantly update.

Quite straightforward. Sorts each file into folders exclusively based on their extension.

The only option that uses a cascading context menu(nested menus).

Sorts each file by the DATE MODIFIED attribute of the file. Has three options:

Sorts up to the Day modified. Takes into account the year, month, and day.

shortcuts
├── _2019-05-16
├── _2019-05-19
├── _2019-05-24
└── _2019-06-28

Sorts up to the Month modified. Takes into account the year and month.

shortcuts
├── _2019-05
└── _2019-06

Sorts up to the Year modified. Takes into account only the year. ‘

shortcuts
└── _2019

The only option that isn’t actually a sort. Recursively moves every file of every subdirectory from the current location to the current location. Useful for getting rid of unnecessary folders and flattening out a directory. For example:

  dummies
  ├── Others
  │   └── database.accdb
  ├── audio
  │   ├── _2019-12-06
  │   │   └── music.mp3
  │   └── _2019-12-28
  │       └── music_.mp3
  ├── documents
  │   ├── _docx
  │   │   ├── document.docx
  │   │   ├── essay.docx
  │   │   └── grades.docx
  │   └── _txt
  │       └── notes.txt
  ├── executables
  │   └── test.py
  └── videos
      └── video.mp4

Would be converted to:

dummies
├── database.accdb
├── document.docx
├── essay.docx
├── grades.docx
├── music.mp3
├── music_.mp3
├── notes.txt
├── test.py
└── video.mp4

BE VERY CAREFUL USING THIS! It is easy to permanently ruin a directory or files, especially if something relies on a specific folder tree, for example the windows directory.

If you are working with the source files do NOT move the files after running reginstall.py as it might cause the code to be unstable. The registry points to the absolute path of the files when installed and does not update.

Files shouldn’t be deleted or corrupted, as they haven’t through all my testing so far. But keep in mind anything is possible, and if you data is THAT important you should probably back it up somewhere. Keep in mind I am NOT responsible for any damages that may arise from this program. Use it at your own risk.

I also created some articles about this project! Check them out:

• Creating Cascading Context Menus
• Uploading functional projects to PIP

This project is licensed under the terms of the MIT license.