Forem: Peter Ade-Ojo

Unlocking Actionable Transaction Insights: Weighted Averages for Accurate Predictions

Peter Ade-Ojo — Thu, 29 Jun 2023 03:40:28 +0000

Imagine you are part of a multi-million dollar, multi-national company that provides financial services for small and medium enterprises across the continent. You want to provide your users with real-time information on the performance of transaction attempts from various finance institutions. This data will empower businesses to make informed decisions about when and how to carry out successful transactions.

The Challenge: Lack of Comprehensive Data

However, gathering data from all finance institutions is a daunting task. While you have access to a substantial amount of data generated on your platform, it's important to acknowledge that you don't have access to all the transaction data in real-time. This limitation hinders your goal of providing up-to-the-minute information.

Weighted Averages: A Statistical Approach for Actionable Insights

What if we could still provide a fairly accurate representation of the state of affairs, even without all the transaction data? This is where statistical analysis comes into play. By using a technique known as weighted averages, we can calculate the reliability of transactions performed by different financial institutions.

Understanding Weighted Averages

Weighted averages involve assigning different weights to sets of transaction data to denote their relevance. The most recent data is given the highest weight, while older data receives lower weights. This approach ensures that we prioritize the most up-to-date information when assessing transaction reliability.

Let's break down the calculation process step-by-step:

Data Collection: Acquire the latest transaction data from your customers using methods like websockets, database integrations, or API connections.
Defining Relevance: Determine a specific time period within which the data is considered relevant. For example, let's choose a 20-minute interval. Any data older than 20 minutes will be considered less reliable.
Data Aggregation: Group the transaction data into sets based on a specific time interval. In our scenario, we'll use one-minute intervals. Each set will aggregate the successful and failed transactions for a particular financial institution, such as Acme Bank.
Assigning Weights: Assign weights to each set of data to denote relevance. We can use a descending scale where the most recent set receives the highest weight (e.g., 20) and the oldest set receives the lowest weight (e.g., 1).
Calculating Weighted Averages: Multiply the number of successful and failed transactions in each set by their respective weights. Then, sum up the weighted results for both successful and failed transactions.
Determining Success Rate: Calculate the success rate by dividing the sum of successful transactions by the sum of successful and failed transactions. This provides a reliable measure of transaction success likelihood.

The Technicalities: Unveiling Transaction Insights

Now that we understand the importance of weighted averages in assessing transaction reliability, let's dive into the technical details. Don't worry; I'll guide you through the process with a friendly and approachable tone.

Step 1: Acquiring the Latest Data

Before we can work our magic with weighted averages, we need to get our hands on the freshest transaction data. You already have a means of acquiring this data from your customers, whether it's through websockets, database connections, or APIs. This ensures you stay up to speed with the latest happenings.

Step 2: Defining Relevance and Data Aggregation

To keep things organized, we'll define a specific time period that we consider relevant. Let's say we opt for a 20-minute interval, but feel free to adjust it to your preference. Within this timeframe, we'll break down the data into sets based on smaller intervals. For our scenario, one-minute intervals should do the trick.

Step 3: Weighing the Importance

Now, here's where the magic happens. We assign weights to each set of data, indicating their significance. Think of it as giving priority to the cool kids on the block - the more recent the data, the higher the weight. We'll use a descending scale, where the most recent set receives the weight of 20, and the oldest set gets a weight of 1. This way, we ensure our analysis is based on the most up-to-date information.

Step 4: Crunching the Numbers

With our sets of data and their respective weights in place, we're ready to crunch some numbers. Brace yourself; it's easier than it sounds! For each set, multiply the number of successful transactions by the corresponding weight and sum them up. We'll do the same for the failed transactions, but with a fixed weight of 1 since we're only interested in their occurrence.

Step 5: Unveiling the Success Rate

Now, the moment of truth: the success rate calculation! Take the sum of successful transactions we just calculated and divide it by the sum of successful and failed transactions. Voila! That's your success rate - a reliable measure of the likelihood that a transaction will go smoothly within your platform and for your customers' customers.

Empowering Users with Actionable Insights

You've done it! By employing this statistical approach, you're now equipped to provide your customers with actionable transaction insights, and you can provide your customers with valuable insights into transaction reliability. Armed with this information, businesses can make more informed decisions and develop strategies to optimize their financial operations. It's important to remember that these insights are specific to your platform and your customers' customers.

Connect with me on twitter @boluwatifee__ and feel free to go through my github profile @peteradeojo

Sending E-mails in PHP with PHPMailer

Peter Ade-Ojo — Fri, 10 Mar 2023 16:25:22 +0000

Introduction
Requirements
Setup
Sending Emails with PHPMailer

Introduction

Welcome to this tutorial on how to send emails using PHP! Communication is key, and emails are an essential part of keeping in touch with your users. In this article, we will walk through the process of sending emails using PHP and PHPMailer - a powerful library for sending emails in PHP. We'll also cover how to configure PHPMailer to use SMTP, which is the most common way of sending emails on the web.

We understand that setting up emails can be daunting, but don't worry! We'll guide you through each step in a friendly and professional manner, ensuring you have everything you need to get started. As an added bonus, we'll show you how to use environment variables in this project - a useful technique for securely storing sensitive information like passwords and API keys.

So whether you're a beginner or a seasoned developer, let's dive in and learn how to send emails with PHP!

Requirements

To follow this tutorial, you will need the following installed on your computer:

PHP (version 7.2 or higher)
Composer
A text editor (e.g. VS Code)
Git (optional)

Setup

First, clone the repository for this tutorial into an empty repository or download the source code and unzip.

$ git clone https://github.com/peteradeojo/sending-mails-with-phpmailer.git

Next, navigate into the project directory and install the dependencies using Composer.

$ cd sending-mails-with-phpmailer
$ composer install

This installs a couple of dependencies for us.

PHPMailer - the library we will use to send emails.
DotEnv - a popular library that allows us to use environment variables in our project.

Great point! Before we proceed with the email sending process, we need to create a .env file in the root directory of our project. This file will contain the environment variables that we'll use throughout our project, such as our SMTP credentials and email recipient addresses.

To load the .env file, we'll use the Dotenv\Dotenv class. We'll call the load() method to load the contents of the .env file into our project. To make things even simpler, we recommend copying the contents of the .env.example file into the .env file.

This way, you'll have a template for the environment variables you'll need, and you can fill in the appropriate values for your project. With that done, we'll be ready to move on to the next step and start sending emails with PHPMailer.

Sending Emails with PHPMailer

Firstly, navigate to the root directory of our project in your text editor and create a new file called index.php.

Next, we'll need to require the vendor/autoload.php file that was automatically generated by Composer when we installed our dependencies. This file contains all the dependencies that we installed and allows us to use them in our project.

To do this, we'll add the following line of code at the top of our index.php file:

<?php

require_once 'vendor/autoload.php';

This code will include the autoload.php file located in the vendor directory of our project. With this done, we'll be able to use PHPMailer and any other dependencies that we've installed using Composer.

Using Environment Variables - You can Skip this part

Using environment variables is a best practice for protecting sensitive information such as credentials from being exposed in source control. To use environment variables in our project, we first need to load the .env file.

To do this, we can use the Dotenv\Dotenv class and call the createImmutable() method to create a new instance of the class. We'll pass in the __DIR__ constant as an argument to specify the current directory as the base directory for our project.
// ... (require autoload.php omitted for brevity)

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$username = $_ENV['USERNAME'];
By using environment variables, we can keep sensitive information secure and prevent it from being exposed in our source code.

Import the necessary classes for PHPMailer by adding the following lines to the top of your index.php file:

// Import PHPMailer classes and exceptions
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
use PHPMailer\PHPMailer\SMTP;

Then, we can proceed with the rest of the code in our index.php file:

// ... (require autoload.php omitted for brevity)


// Create a new instance of PHPMailer
$mail = new PHPMailer(true);

try {
    //Server settings
    $mail->SMTPDebug = SMTP::DEBUG_SERVER; //Enable verbose debug output
    $mail->isSMTP(); //Send using SMTP
    $mail->Host = $_ENV['SMTP_HOST']; //Set the SMTP server to send through
    $mail->SMTPAuth = true; //Enable SMTP authentication
    $mail->Username = $_ENV['SMTP_USERNAME']; //SMTP username
    $mail->Password = $_ENV['SMTP_PASSWORD']; //SMTP password
    $mail->SMTPSecure = PHPMailer::ENCRYPTION_SMTPS; //Enable SSL encryption
    $mail->Port = $_ENV['SMTP_PORT']; //TCP port to connect to, use 587 for `PHPMailer::ENCRYPTION_STARTTLS` above

    //Recipients
    $mail->setFrom('from@example.com', 'Mailer');
    $mail->addAddress('johndoe@example.com', 'John Doe'); //Add a recipient

    //Content
    $mail->isHTML(true); //Set email format to HTML
    $mail->Subject = 'Here is the subject';
    $mail->Body = 'This is the HTML message body <b>in bold!</b>';
    $mail->AltBody = 'This is the body in plain text for non-HTML mail clients';

    $mail->send();
    echo 'Message has been sent';
} catch (Exception $e) {
    echo "Message could not be sent. Mailer Error: {$mail->ErrorInfo}";
}

In this code, we create a new instance of PHPMailer and configure its settings to send an email.

We set the SMTPDebug property to SMTP::DEBUG_SERVER to enable verbose debug output, which is useful for testing and troubleshooting.

We set the isSMTP property to true to indicate that we will send the email using SMTP.

We then set the SMTP server to send through, the SMTP authentication credentials, and the encryption settings. These values are loaded from the .env file using the $_ENV superglobal array.

Next, we set the recipients of the email using the setFrom and addAddress methods.

We set the email format to HTML using the isHTML method and then set the subject and body of the email using the Subject, Body, and AltBody properties.

Finally, we call the send method to send the email. If the email is sent successfully, we output a message to the user. If there is an error, we output a message with the error information.

I hope this helps you send emails in PHP using PHPMailer!

Transitioning from MySQL to MongoDB

Peter Ade-Ojo — Mon, 25 Oct 2021 09:10:17 +0000

Introduction
SQL Databases
NoSQL Databases
MongoDB
Setting Up
- Installing
- Creating a Model
- Connecting to the Database
Creating/Inserting Data
Retrieving Multiple Records
Selecting One Record
- By ID
- By Attribute
Updating Records
Deleting Records
Conclusion
Read the Docs

Introduction

When going into software development, for most web applications, there is a need to store data, persistently, in some form or the other. This could include the need to store login/authentication information, financial details, an e-shopper's cart, training data for a machine learning model, etc. Amazingly, there are myriads of ways to store this data, examples include JSON (JavaScript Object Notation), XML, CSV (comma-separated values), or in a database, the most popular option, of course, being the most popular of them all.

This article will not discuss the different types of database systems, like RDBMS and so on. We will, however, focus on two concepts: SQL Databases and NoSQL databases.

SQL Databases

SQL (Structured Query Language) is a standardized programming language that's used to manage relational databases and perform various operations on the data in them. Read More.

The data in relational databases is stored in rows and columns which are arranged in relevant tables and stored in the overall database.

NoSQL Databases

According to the MongoDB Webpage, NoSQL databases (aka "not only SQL") are non-tabular databases and store data differently than relational tables. NoSQL databases come in a variety of types based on their data model. The main types are document, key-value, wide-column, and graph. They provide flexible schemas and scale easily with large amounts of data and high user loads.

The NoSQL database of choice we would be looking at today is MongoDB.

MongoDB

MongoDB is the most popular solution for developers looking to benefit from features like scalability and speed. Unlike MySQL, MongoDB returns data as a well-organized, JSON document with helper methods that help to execute more complex queries on the data.

In place of tables, MongoDB uses a Schema, which defines the datatypes, constraints, and other parameters to construct Models that represent tables and are the ways we access, create and modify data. These models are then used to organize data into collections.

If you're used to viewing data in a graphical form such as PHPMyAdmin for MySQL, MongoDB also has the MongoDB Compass, to provide such capability.

Setting Up

To go through this article, we'll use the Mongoose npm package.

Installing

The file structure for this project will look something like this.

----/
    |
    |--app.js
    |--package.json
    |--models
        |--User.js

Run the following commands in this folder.

> npm init -y
> npm install mongoose nodemon

Inside package.json, under scripts, include the following

...
"start": "nodemon app.js"
...

Creating a Model

Inside User.js, we'll create a Mongoose Model with the following lines of code

const mongoose = require('mongoose');
const {Schema} = mongoose;

const userSchema = new Schema({
  username: {
    type: String,
    required: true,
    unique: true,
  },
  password: {
    type: String,
    required: true,
  },
  name: {
    type: String,
    required: true
  }
});

module.exports = mongoose.model('User', userSchema);

The SQL equivalent of this would look something like this

CREATE DATABASE `transition-tutorial`;

USE `transition-tutorial`;

CREATE TABLE `users` (
  id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(20) NOT NULL,
  username VARCHAR(20) NOT NULL UNIQUE,
  password VARCHAR(20) NOT NULL
);

Here we can see how we use Schema to define the data structure and parameters, and then process it into, and export a Model object. Additionally, notice how we didn't define an id property in our Schema. That's because MongoDB automatically assigns a 16-bit unique ObjectId to all documents in the model. Amazing.

Connecting to the Database

Inside app.js, write the following lines of code

const mongoose = require('mongoose');
const User = require('./models/User');

(async () => {
  try {
    await mongoose.connect(
        'mongodb://127.0.0.1:27017/transition-tutorial', 
        options);
  } catch (err) {
    console.log('Error connectiong to Database');
    console.log(err);
  }
});

And here, we include the constructed model object into our file.

Two things to note

We see from the connection that Mongoose is designed to work in an asynchronous environment. Mongoose supports both promises and callbacks.
The string 'mongodb://127.0.0.1:27017' represents the connection URL for the mongoose instance. The URL in this tutorial is for those who have the MongoDB application installed on their local computer. Connecting to a cloud instance requires a connection string gotten from your MongoDB Cloud cluster homepage.
The 'transition-tutorial' is the name of the database we will be querying. We did not create this database because MongoDB automatically creates it along with any defined Model when we connect and insert our first document using that Model Object. Another amazing reason to switch to MongoDB.

Now, run npm start in the terminal.

Creating/Inserting Data

Typically, in an SQL database, the way to insert data into a table would be

INSERT INTO `users` (name,username,password) VALUES ('John', 'johnsmith', 'p@$$w0rd!');

The MongoDB equivalent of this would be

...
(async () => {
  try {
    const user = new User({name: 'John', username: 'johnsmith', password: 'p@$$w0rd!'});
    await user.save();
    console.log(user);
  } catch (err) {
    console.log(err);
  }
})();

If you take a look at the output in the terminal or console, you'll notice that the new User Object has an _id property. This is the unique id that was generated by Mongoose;

Retrieving Multiple Records

To retrieve data from a SQL database, for example users, you'd usually write a query like this

SELECT * FROM users

This corresponds to following line of code

(async () => {
  const users = await User.find({});
  console.log(users);
});

This returns an array of MongoDB documents.

To perform a WHERE query, simply add the conditions as properties in the find method.

const users = await User.find({name: 'John'});

This retrieves all users who have the name John while

To only retrieve some properties, supply a comma-separated string as the second parameter.

const users = await User.find({}, 'name, username');

This will return only the name and username properties, as well as the unique _id. The SQL equivalent of this would look like

SELECT name, username FROM users;

Selecting One Record

By ID

This would find and return records based on the unique ID, provided you already have the id

const user = await User.findById(id);
console.log(user);

By Attribute

To return one document using one of the properties, for example, the name, write this

const user = await User.findOne({name: 'John'});

This returns the first user in the collection with the name John.

The SQL equivalent of this would look like

SELECT * FROM users WHERE name='John';

Updating Records

To update a record in a SQL database, we use the UPDATE query

UPDATE TABLE users SET password='johnsmith001' WHERE name='John';

To achieve this in MongoDB, we could go two ways

First, we could retrieve the data from the database, update the document and then save it again.

const user = await User.find({name: 'John'});
user.password = 'johnsmith001';
await user.save();

Secondly, we could findAndUpdate, findOneAndUpdate or updateOne and the documents directly.


  // Update multiple documents
  const user = await User.findAndUpdate(
    {}, 
    {password: 'johnsmith001'},
    {new: true}
  );

  // Update multiple documents with condition
  const user = await User.findAndUpdate(
    {name: 'John'}, 
    {password: 'johnsmith001'},
    {new: true}
  );

  // Update single document
  const user = await User.findOneAndUpdate(
    {name: 'John'}, 
    {password: 'johnsmith001'},
    {new: true}
  );

  // Update single document
  const user = await User.updateOne(
    {name: 'John'}, 
    {password: 'johnsmith001'},
  );

The first parameter to pass is an object of the conditions used to locate the required document, the second parameter is an object of the updates to be made to the document, and the {new: true} tells mongoose to return the updated record. If this is not included, the old, outdated document will be returned instead.

Deleting Records

To delete records in a SQL database, the typical query would look like this.

DELETE FROM users WHERE name='John';

The equivalent mongoose function would resemble any one of the following ways

// Deleting collection of documents
const users = await User.deleteMany({name: 'John'});
const users = await User.remove({name: 'John'});
// returns {deletedCount: x} where x is the number of documents deleted.

// Deleting Single Document
const user = User.findOneAndDelete({name: 'John'});
console.log(user); // returns the deleted document

Note:

The deleteMany method is preferred over the remove unless you have a good reason otherwise.

Conclusion

We've taken a look at the common operations that can be performed by querying a SQL database and the ways they can be implemented in MongoDB using mongoose. Don't stop there. There are many other things we could discuss such as implementing the LIKE query by passing a regex as the find condition and implementing JOIN queries with the populate method.

Create a MongoDB account for free today and take advantage of all the features MongoDB has to offer.

Forem: Peter Ade-Ojo

Unlocking Actionable Transaction Insights: Weighted Averages for Accurate Predictions

The Challenge: Lack of Comprehensive Data

Weighted Averages: A Statistical Approach for Actionable Insights

Understanding Weighted Averages

The Technicalities: Unveiling Transaction Insights

Step 1: Acquiring the Latest Data

Step 2: Defining Relevance and Data Aggregation

Step 3: Weighing the Importance

Step 4: Crunching the Numbers

Step 5: Unveiling the Success Rate

Empowering Users with Actionable Insights

Sending E-mails in PHP with PHPMailer

Introduction

Requirements

Setup

Sending Emails with PHPMailer

Using Environment Variables - You can Skip this part

Transitioning from MySQL to MongoDB

Table of Contents

Introduction

SQL Databases

NoSQL Databases

MongoDB

Setting Up

Installing

Creating a Model

Connecting to the Database

Creating/Inserting Data

Retrieving Multiple Records

Selecting One Record

By ID

By Attribute

Updating Records

Deleting Records

Conclusion

Read the Docs