If you run an app, a website, or even a side project, you already know the truth: things break at the worst possible time.

A server goes down. A deployment misbehaves. A background job silently fails. And the real pain is not that it happened, it’s that you didn’t find out until users did.

That’s exactly why I built a new, simple webhook tool that anyone can use for free. It’s designed to help you notify yourself when something goes wrong, without needing to set up a full monitoring stack.

What it does

At its core, the app is a webhook endpoint you can call from anywhere.

When your system detects a problem, you send a request to the webhook. The app will:

• Log everything you send so you have a clear record of incidents and payload details
• Send an email notification so you know immediately something needs attention

This works great for:

• Uptime checks (site is down, API is unreachable)
• Error handlers (your app catches an exception and reports it)
• Automation failures (a scheduled job didn’t run, a workflow crashed)
• Anything else that deserves a “hey, look at this now” message

Built for simplicity

You don’t need to install an agent. You don’t need special infrastructure.

If your app can make an HTTP request, you can use this. That means it fits neatly into server-side applications, CI/CD pipelines, cron jobs, and no-code tools that can call webhooks.

Email notifications (free, with a fair limit)

To keep it free and reliable for everyone, email sending includes a small cap:

• Up to 5 email notifications per day

That’s usually enough to cover “something is down” or “something is failing” without turning your inbox into a firehose.

Need higher limits? Use your own email provider via Brevo

If your use case requires more than 5 emails a day, you can plug in your own email sending through Brevo using the custom API option.

• Emails are sent using your own Brevo account
• Your sending capacity depends on your Brevo plan and limits
• You keep full control over deliverability and scale

This keeps the app simple for everyone, while power users can scale without friction.

Why I made this

Monitoring tools are great, but not everyone needs a complex platform or paid plan just to get basic alerts.

Sometimes you just want a webhook you can hit, a log of what happened, and an email that tells you to go check. This is built to be that lightweight missing piece.

Get started

Start sending events in minutes. Use it for uptime pings, error reports, or “this should never happen” alerts. The app will store the payload and notify you so you can take action fast.

Try it here! 👈🏽 

This project came from a personal need. I wanted a clean and straightforward way to track my expenses, understand my monthly spending, and see how much I was actually saving. Instead of adding complexity, the focus was on building something practical, fast, and easy to use.

Clear Monthly Overview

The webapp provides a straightforward monthly overview that shows total expenses at a glance. This makes it easy to stay aware of your spending habits without manually reviewing every transaction. With one look, users can understand how their month is shaping up financially.

Smart Filtering for Better Insights

To help users dive deeper into their data, the webapp supports filtering by date range and category. Whether you want to review spending from the last few days or analyze specific categories like food, transport, or entertainment, filtering turns raw data into meaningful insights.

This flexibility makes it easier to identify trends, spot unnecessary expenses, and adjust habits accordingly.

Built-In Budgeting

Budgeting is a key part of staying in control of your finances. The webapp allows users to set a budget and track progress in real time. Instead of guessing where your money stands, you can instantly see how much you have spent and how close you are to your limit.

See How Much You Save

Beyond tracking expenses, the webapp highlights savings in a clear and motivating way. By comparing spending against the set budget, users can immediately see how much money they are saving. This turns financial discipline into something visible and rewarding.

Designed to Be Simple

The strength of this webapp lies in its simplicity. Every feature has a clear purpose and is easy to use. By keeping the experience focused and distraction-free, users can manage their finances quickly and confidently.

Start Tracking Your Expenses Today

If you are looking for a practical and easy way to stay on top of your finances, this webapp is ready to use.

👉 Try the webapp here:
https://paylog.cyfervoid.com

Thanks for reading, and more projects and write-ups are coming soon.

Recently, my PHP-based application went down—completely unresponsive. No errors, no crashes—just a blank, stalled site. Sound familiar?

Diagnosing the Problem

I suspected something with PHP-FPM, so I checked its status on my Ubuntu server:

sudo systemctl status php8.1-fpm

The result?

Status: "Processes active: 5, idle: 0, Requests: 13432, slow: 0, Traffic: 0.00req/sec"

This told me:

• All PHP workers were busy (Processes active: 5)
• No idle workers available (Idle: 0)
• Traffic had stopped despite of 5 active processes

That explained the freeze: PHP-FPM was overloaded.

✅ The Quick Fix: Restart PHP-FPM

To bring the site back online instantly, I ran:

sudo systemctl restart php8.1-fpm

After that, the server started handling traffic again and the site was back.

Why It Happened: PHP-FPM Limits

By default, PHP-FPM allows only a limited number of concurrent worker processes. If your site gets too many simultaneous requests, those processes can all get occupied — and when they’re full, new requests just wait (or time out).

The Real Fix: Increase Worker Limits

To avoid this in the future, I edited PHP-FPM’s config:

sudo nano /etc/php/8.1/fpm/pool.d/www.conf

And changed:

pm = dynamic
pm.max_children = 10         ; was 5
pm.start_servers = 3         ; was 2
pm.min_spare_servers = 2     ; was 1
pm.max_spare_servers = 5     ; was 3

Then reloaded the service:

sudo systemctl restart php8.1-fpm

Now, my server can handle more concurrent users without freezing up.

Bonus Tip: Monitor in Real-Time

Keep an eye on PHP-FPM activity with:

sudo journalctl -fu php8.1-fpm

And monitor Nginx/Apache logs:

sudo tail -f /var/log/nginx/error.log

Conclusion

If your PHP site suddenly freezes up, don’t panic. Check your PHP-FPM status — you might just need a quick restart. But for long-term stability, increasing the number of PHP worker processes based on your traffic is the way to go.

The ICC’s Arrest Warrant: What Does It Actually Say?
On March 2024, the ICC issued an arrest warrant against Rodrigo Duterte and other officials for alleged crimes against humanity linked to the Philippine government’s war on drugs. Contrary to widely circulated figures of thousands or even tens of thousands of deaths, the official document explicitly mentions 43 cases in its allegations.

The ICC’s document states that these 43 incidents were selected based on specific evidence gathered from witnesses, forensic reports, and official government data. The document does not claim that these are the only deaths, but it does not substantiate the frequently quoted higher figures.

The Media’s Death Toll: Where Do the Numbers Come From?
Major news outlets and human rights organizations have often cited figures between 6,000 and 30,000 deaths attributed to the Philippine drug war. These numbers come from various sources, including:

• Philippine National Police (PNP) Data: The PNP has officially reported around 6,252 deaths in anti-drug operations from 2016 to 2022.
• Human Rights Groups: Organizations such as Amnesty International and Human Rights Watch estimate the death toll to be much higher, often citing community reports and undocumented cases.
• Media Reports: Some reports rely on statements from opposition groups, activists, and anecdotal evidence rather than official documentation.

The lack of a single, verifiable database means these estimates remain controversial. The ICC’s reliance on 43 cases suggests that its prosecution team did not find sufficient evidence to support claims of 6,000+ confirmed extrajudicial killings.

Why the Discrepancy?

1. Legal Burden of Proof: The ICC requires evidence strong enough to hold up in court. While thousands of deaths may have been reported, proving them as state-sanctioned extrajudicial killings requires specific documentation.
2. Media Sensationalism: High numbers generate more attention and fit a specific narrative that Duterte’s war on drugs was a “mass murder campaign.” However, without solid verification, these claims remain speculative.
3. Political Motivations: The ICC’s case is inherently political, as it involves international intervention in a sovereign nation’s affairs. Opposing political factions may have incentives to exaggerate figures.

The Role of Biased Media

• Selective Reporting: Many international and local media platforms highlight unverified death tolls while downplaying official statistics that contradict their narrative.
• Reliance on Opposition-Backed Sources: Reports often cite activist groups and political opponents without cross-checking information with independent sources.
• Ignoring Positive Outcomes: Media coverage rarely acknowledges the significant reduction in crime rates and drug-related incidents resulting from Duterte’s policies.

This pattern of reporting suggests an agenda-driven approach rather than objective journalism, reinforcing public misconceptions and creating an international image of the Philippines that aligns with political interests.

Implications for the Philippines and Duterte

• Legal: Duterte’s defense team could argue that the limited number of cases in the ICC warrant weakens the genocide or mass killing accusations.
• Political: The discrepancy may fuel skepticism about international organizations’ fairness and objectivity in prosecuting leaders of developing nations.
• Media Accountability: The case underscores the need for responsible journalism that verifies claims rather than amplifies unproven figures.

Conclusion
The ICC’s arrest warrant for Duterte highlights a significant gap between media narratives and legal documentation. While the war on drugs remains a contentious issue, the actual charges against Duterte are based on a much smaller number of cases than many were led to believe. This raises critical questions about how information is reported, the political interests involved, and the credibility of both international legal bodies and media outlets.

As the case progresses, it is essential to separate facts from speculation and ensure that justice—whether for the accused or the victims—is based on truth, not manipulated numbers.

Disclaimer:
This website primarily focuses on computer programming and technology-related content. However, as a concerned Filipino citizen, I cannot ignore the recent events unfolding in our country. While this article deviates from my usual topics, I feel compelled to express my thoughts on the unjust arrest of former President Rodrigo Duterte. This is a personal reflection on the situation, driven by disappointment and a call for fairness.

A Questionable Arrest
The arrest of former President Rodrigo Duterte under the International Criminal Court (ICC) warrant has ignited controversy not only in the Philippines but around the world. Duterte, who served as the country’s leader from 2016 to 2022, gained popularity for his aggressive anti-drug campaign. While critics claim this campaign led to human rights violations, his supporters argue that it significantly reduced crime and improved public safety.

Duterte’s arrest raises several legal and ethical questions. The Philippines formally withdrew from the ICC in 2019, meaning that its jurisdiction over the country is highly debatable. If the Philippines is no longer a member of the ICC, then why is this warrant being enforced?

Political Persecution Disguised as Justice?
Many believe that this arrest is less about justice and more about eliminating a strong political figure who remains highly influential. Duterte’s popularity among Filipinos remains strong, and his family continues to hold powerful political positions. His daughter, Sara Duterte, is currently the Vice President, making her a direct rival to the current administration.

The timing of the arrest raises even more suspicion. With midterm elections approaching, could this be a strategic move to weaken Duterte’s political allies and prevent them from gaining momentum? The arrest of a former leader on international charges, despite the Philippines’ non-membership in the ICC, suggests a coordinated effort to discredit his legacy.

The Hypocrisy of International Intervention
It is also worth questioning why the ICC is so determined to prosecute Duterte when other global leaders accused of war crimes remain free. There are world leaders responsible for mass killings, yet they continue to enjoy diplomatic immunity. Why is the ICC prioritizing Duterte over more pressing international crimes?

The arrest also disregards the Philippine judicial system, implying that local institutions are incapable of handling their own legal matters. This undermines the country’s sovereignty and raises concerns about foreign influence in domestic affairs.

The People's Voice
Despite the controversy, many Filipinos continue to support Duterte, citing his leadership’s tangible improvements in security and economic stability. Massive protests have erupted nationwide, with supporters calling for his immediate release. Their argument is simple: if Duterte committed crimes, he should be tried by Philippine courts, not an international body with questionable authority over the country.

Conclusion: A Fight for Justice
Duterte’s arrest is a dangerous precedent that could be used against any leader who dares to challenge powerful interests. Whether one agrees with his policies or not, his fate should be determined by the Filipino people and Philippine courts, not an external institution.

The fight is not just about Duterte—it’s about protecting national sovereignty and ensuring that justice is not manipulated for political gain. If the rule of law is truly the goal, then fair legal proceedings within the Philippines must take precedence over foreign intervention.

Disclaimer:
This website primarily focuses on computer programming and technology-related content. However, as a concerned Filipino citizen, I cannot ignore the recent events unfolding in our country. While this article deviates from my usual topics, I feel compelled to express my thoughts on the unjust arrest of former President Rodrigo Duterte. This is a personal reflection on the situation, driven by disappointment and a call for fairness.

Introduction to Python

Python is a high-level, interpreted programming language. It is widely used in various domains such as web development, data analysis, artificial intelligence, and more.

Why Learn Python?
>

• Easy to read and write
• Extensive community support
• Versatile and widely used in various industries
• Open-source and free to use

Installing Python
To get started with Python, you need to install it on your computer. Download the latest version from python.org and follow the installation instructions.

To check if Python is installed, open a terminal or command prompt and type:

python --version

Writing Your First Python Program

Once Python is installed, you can write and run your first program. Open a text editor or the Python interactive shell and type:

print("Hello, World!")

Save the file as hello.py and run it using:

python hello.py

You should see the output:

Hello, World!

Python Basics

Variables and Data Types
Variables store data in Python. You don’t need to declare the type explicitly:

name = "Alice"  # String
age = 25        # Integer
height = 5.6    # Float
is_student = True  # Boolean

Basic Input and Output
Python allows user input using input():

name = input("Enter your name: ")
print("Hello, " + name + "!")

Operators
Python supports different types of operators:

x = 10
y = 5
print(x + y)  # Addition
print(x - y)  # Subtraction
print(x * y)  # Multiplication
print(x / y)  # Division
print(x % y)  # Modulus

Control Flow

Conditional Statements
Python uses if, elif, and else for decision-making:

age = int(input("Enter your age: "))
if age >= 18:
    print("You are an adult.")
elif age >= 13:
    print("You are a teenager.")
else:
    print("You are a child.")

Loops
For Loop

for i in range(5):
    print("Iteration:", i)

While Loop

count = 0
while count < 5:
    print("Count:", count)
    count += 1

Functions

Functions help organize code into reusable blocks:

def greet(name):
    print("Hello, " + name + "!")

greet("Alice")
greet("Bob")

Lists and Dictionaries

Lists
Lists store multiple items in a single variable:

fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # Output: apple

Dictionaries
Dictionaries store key-value pairs:

person = {"name": "Alice", "age": 25}
print(person["name"])  # Output: Alice

File Handling

Reading a File

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Writing to a File

with open("example.txt", "w") as file:
    file.write("Hello, Python!")

Error Handling

Python uses try-except to handle errors:

try:
    x = int(input("Enter a number: "))
    print(10 / x)
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter a number.")

Conclusion

Congratulations! You have learned the basics of Python programming. From writing simple scripts to handling user input and errors, you now have a solid foundation to explore more advanced topics like object-oriented programming, web development, and data science.

Next Steps
l>

• Explore Python libraries like NumPy, Pandas, and Flask
• Build small projects to strengthen your understanding
• Join Python communities for support and learning

Happy Codding!

Pros:

• Affordable Pricing: Hostinger offers some of the most budget-friendly hosting plans without compromising on features.
• Fast Load Times: Consistently delivers fast website load speeds.
• User-Friendly Interface: An intuitive control panel with easy-to-use tools.
• Free Domain and SSL: Many plans come with a free domain name and SSL certificate.
• Excellent Customer Support: 24/7 live chat support with knowledgeable representatives.
• Multiple Data Centers: Servers located in the US, Europe, Asia, and South America.

Cons:

• No Phone Support: Customer support is only available via live chat.
• Limited Resources on Basic Plans: Entry-level plans have resource limits.
• Paid Backups on Basic Plans: Automated backups are not included in the cheapest plan.

Hostinger VPS Hosting Plans and Features

Performance

Hostinger excels in performance with an average uptime of 99.9% and fast load times thanks to its use of LiteSpeed web servers and SSD storage. Its global data centers ensure that users experience minimal latency, no matter where they are located.

Security

Hostinger offers robust security measures including free SSL certificates, DDoS protection, daily or weekly backups (depending on the plan), and a web application firewall. Regular updates and proactive monitoring help keep websites secure.

Customer Support

Hostinger’s 24/7 customer support is available through live chat, providing quick and helpful responses. While there is no phone support, the extensive knowledge base and tutorials make troubleshooting easy.

Why Choose Hostinger VPS Hosting?

Hostinger stands out for its budget-friendly pricing without compromising on essential features. With scalable plans, robust performance, and a user-friendly control panel, it is a top choice for developers, small businesses, and bloggers.

Verdict

Hostinger stands out as an affordable yet reliable web hosting provider, perfect for small to medium-sized websites, startups, and individual bloggers. Its competitive pricing, excellent performance, and strong customer support make it a highly recommended choice in 2025. Although it has minor drawbacks like limited resources on basic plans and no phone support, its overall value is hard to beat.

Whether you’re starting a new blog, setting up an e-commerce store, or looking for a reliable host for your business website, Hostinger offers a solid solution that won’t break the bank.

Sign up for Hostinger VPS hosting here

1. Keep Ubuntu Updated

Regular updates ensure your system runs smoothly with security patches and performance improvements.

sudo apt update && sudo apt upgrade -y

2. Reduce Cache Usage

The APT package manager stores downloaded package files, which can consume disk space over time.

sudo apt clean && sudo apt autoclean

To remove unnecessary packages:

sudo apt autoremove -y

To clear memory cache, execute:

sudo sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

3. Manage Logs Efficiently

Ubuntu logs system events and can accumulate large log files over time.

Check the current log size:

journalctl --disk-usage

Set log retention limit (e.g., 100MB):

sudo journalctl --vacuum-size=100M

Limit logs to last 3 days:

sudo journalctl --vacuum-time=3d

Ensure logs are rotated and old logs are deleted by configuring Logrotate.

Edit the configuration:

sudo nano /etc/logrotate.conf

Modify settings such as:

weekly
rotate 4
compress

4. Disable Unnecessary Services

List enabled services:

systemctl list-unit-files --type=service --state=enabled

Disable unwanted services:

sudo systemctl disable <service_name>

5. Optimize Swappiness

Linux uses swap memory, which can slow down the system if overused. Reduce swappiness to prefer RAM usage:

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

6. Use a Lightweight Web Server (Optional)

If hosting a website, consider using Nginx instead of Apache for better performance:

sudo apt install nginx -y

7. Monitor Server Performance

Install htop to analyze CPU and RAM usage:

sudo apt install htop -y
htop

8. Enable UFW Firewall for Security

Ensure firewall protection with UFW (Uncomplicated Firewall):

sudo ufw enable
sudo ufw allow ssh
sudo ufw status

9. Reduce Boot Time

List services that slow down boot time:

systemd-analyze blame

Disable unnecessary startup services:

sudo systemctl disable <service_name>

10. Optimize Disk Space

Check disk usage:

df -h

Remove old kernels:

sudo apt autoremove --purge

Find and remove large unused files:

sudo du -sh /var/log/*

Conclusion

By implementing these optimizations, you can significantly improve your Ubuntu server’s efficiency, security, and speed. Regular maintenance ensures optimal performance over time. Keep monitoring your system and adjust settings as needed!

In the rapidly evolving landscape of web development, personalization and dynamic content have become paramount. HubSpot CMS Hub offers powerful features that equip developers to create highly engaging and customized websites. One of the keys to unlocking this potential is mastering the creation of custom modules. Whether you're a seasoned developer or new to HubSpot, this guide will walk you through the essentials of building custom modules, enabling you to harness the full capabilities of the CMS Hub.

Understanding HubSpot CMS and Custom Modules

HubSpot CMS Hub is a versatile platform that combines content management with robust marketing tools. Custom modules are reusable blocks of code and design that allow developers to add unique functionality and design elements to a website. These modules are integrated seamlessly into HubSpot's drag-and-drop template builder, enabling greater flexibility in crafting personalized user experiences.

Getting Started with HubSpot Custom Modules

Before diving into module creation, ensure you have the necessary prerequisites:

1. HubSpot Account: You’ll need access to a HubSpot CMS Hub account.
2. Developer Tools: HubSpot provides a local development workflow using the HubSpot CLI, which allows developers to work in local environments.
3. Familiarity with HubL: HubSpot’s templating language, HubL, is crucial for developing modules. Understanding how to use HubL tags and filters will empower you to build dynamic content.

Step-by-Step Guide to Creating Custom Modules

1. Set Up Your Development Environment:

   • Install the HubSpot CLI on your local machine.
   • Authenticate your CLI with HubSpot using your account's API key.
   • Create a local development server to preview your module changes before deploying them to the live site.
     
     

2. Define Your Module:

   • Start by creating a new module file in your HubSpot design manager.
   • Use HTML, CSS, and HubL to define the layout and style of your module.
   • Incorporate conditional logic using HubL to dynamically render content based on user interactions or data inputs.
     
     

3. Add Fields to Your Module:

   • Utilize HubSpot’s module editor to add fields such as text inputs, image selectors, and dropdowns, enabling users to customize the module content.
   • Configure default values and validation rules to ensure consistent and reliable user input.
     
     

4. Test Your Module:

   • Preview your module in the HubSpot test environment to ensure it behaves as expected.
   • Use A/B testing and responsive design techniques to optimize your module for various devices and screen sizes.
     
     

5. Deploy and Integrate:

   • Once tested, deploy your module to the live site.
   • Integrate the module into existing or new HubSpot templates, allowing content creators to easily include it in their pages.

Leveraging HubSpot API for Advanced Customizations

For those looking to push their HubSpot CMS Hub capabilities further, integrating the HubSpot API opens doors to advanced customizations. By connecting external data sources or third-party services, developers can create truly dynamic and connected experiences. The HubSpot API allows for operations such as fetching CRM data, triggering workflows, or interacting with marketing automation features directly within your custom module.

Conclusion

Mastering custom modules in HubSpot CMS Hub is a gateway to creating powerful, personalized websites that can drive engagement and conversions. By following this guide, developers can efficiently extend their web projects’ capabilities, delivering tailored experiences that stand out in today’s competitive digital marketplace. Explore the depth of HubSpot’s development environment and start building innovative web solutions today.

As web applications grow more complex, the need for modular and scalable architectures becomes increasingly pressing. Enter micro-frontends—a burgeoning architectural trend that enables developers to organize code in a way that maximizes flexibility and minimizes overhead. In this article, we'll explore micro-frontends in depth, examining their benefit to modern web development, their architectural setup, and best practices for implementation.

What Are Micro-Frontends?

Micro-frontends extend the concepts behind microservices to the frontend development realm. Traditionally, web applications have been built as monolithic structures, meaning all the frontend code was bundled together. As these applications grow, so does their complexity, making it challenging to maintain or scale them efficiently. Micro-frontends aim to solve this problem by decomposing the frontend into smaller, manageable pieces or "micro-apps," each running its own codebase.

Benefits of Micro-Frontends

1. Independent Deployability: Each micro-frontend can be developed, tested, and deployed independently. This reduces the dependency bottleneck often seen in monolithic applications, speeding up release cycles.

2. Scalability: Different teams can work on different micro-frontends simultaneously without stepping on each other's toes, allowing large applications to scale more easily.

3. Technological Diversity: Teams have the freedom to choose different technologies and frameworks for different parts of the application, allowing them to adopt new tools that best fit specific needs.

4. Improved Maintainability: Breaking down applications into smaller parts means that each micro-frontend can be maintained independently, making applications more resilient and adaptable to change.

Implementing Micro-Frontends

Implementing a micro-frontend architecture requires careful consideration to balance independence and integration. Here's a step-by-step approach to getting started:

1. Define Your Boundaries: Determine how to split your application into micro-frontends. It can be feature-based, page-based, or function-based depending on the application's needs.

2. Choose a Composition Strategy: Options include runtime integration using iframes or JavaScript-based Service Composition and build time integration using frameworks like Webpack Module Federation.

3. Ensure Consistent Communication: Micro-frontends must interact seamlessly. Event Bus or custom APIs can facilitate interactions while ensuring each micro-app remains loosely coupled.

4. Implement Shared Resources Carefully: If certain resources or style guides must be shared, consider creating a shared library that can be versioned and consumed by all micro-frontends.

5. Automate Deployment and Monitoring: Automate pipelines for each micro-frontend and implement monitoring to keep track of their performance and integration health.

Challenges and Considerations

While micro-frontends offer many advantages, they aren't without challenges. Teams must handle greater operational complexity, ensure UI consistency across microfrontends, and manage potential performance issues arising from multiple frontend frameworks.

Conclusion

Micro-frontends represent a significant evolution in web architecture, particularly for complex applications that demand scalability and flexibility. By carefully designing and implementing a micro-frontend architecture, developers can create robust applications that not only perform well today but can also adapt to future technology landscapes. Embracing this trend could be the key to unlocking a more agile and resilient web development strategy.

This tutorial assumes that you already have a web server and a running website locally and you only need to make it available to the world.

First is create a packetriot account as you will going it for authentication later.

Second is download the right variation of packetriot for your machine here: https://packetriot.com/downloads

Extract it to any directory of your choice, in this example we will extract it to D:/Application/Packetriot/

Next is add it to your system variable so you can use packetriot on any directory.

After adding it to your system variable, try it in your windows terminal to check if everything is working.

pktriot version

You should see this response if you have successfully added packetriot in your environment system.

Now the exciting part is to configure the packetriot to make your website available to the world

Type in this in your terminal, pktriot configure

Then select configuration file directory (packetriot will ask and guide you these during the process)

Then login your packetriot account

Then select a region (select your region so it'll be more optimal and load faster)

After that you should see a hostname provided for you by packetriot

Next is to expose your localserver, to do that just type in these into your terminal and hit enter

pktriot tunnel http add --domain  {hosted-provided-by-packetriot} --destination localhost --http 80 --letsencrypt

Now you should be able to access your localhost through the hostname that packetriot provided to you.

Now if you have a custom domain, what you need to do is just type in the same command but instead of hostname that packetriot provided to you, use your domain instead.

pktriot tunnel http add --domain  yourcustomdomain.com --destination localhost --http 80 --letsencrypt

Now login to your domain manager and add a cname record, use your hostname that packetriot provided for you

Also you should add that custom domain in packetriot, login your packetriot into their website and add your domain.

You also need verify it, packetriot will provided you a guide and a TXT record to put in your domain manager to verify that you're the owner of the domain.

After that you should be able to see your website to that custom domain.

My client wanted to add a shipped order status because they want their customers be notified when the item(s) they’ve bought are being shipped.

This code will check the order status shipped and if it doesn’t exists, it will going to add shipped on order status drop-down list.

add_action( 'init', function() {
    $term = get_term_by( 'name', 'shipped', 'shop_order_status' );
    if ( ! $term ) {
        wp_insert_term( 'shipped', 'shop_order_status' );
    }
} );

You’ll be surprised seeing your custom order status added there.

Our next step is to make it look cool when the order status is shipped.

The code below will let you insert anything in the head tag of your wordpress backend and we’re going to use it to insert our css.

function insert_new_css() {
   echo '<style>
   .shipped.tips { background: url("'.get_stylesheet_directory_uri().'/images/shipped.png") no-repeat scroll 50% center rgb(45, 178, 0) !important; }
   </style>';
}
add_action('admin_head', 'insert_new_css');

This is the image I used. 

Now try to change the status of one of the order to shipped and look the result of it.

Great right?

Our next goal is to add shipped order status in the bulk actions, so you can change multiple order status at once.

The code below will add the Mark as Shipped in bulk actions below the Mark as completed.

add_action('admin_footer-edit.php', 'custom_bulk_admin_footer');
function custom_bulk_admin_footer() {
 
  global $post_type;
 
  if($post_type == 'shop_order') {
    ?>
    <script type="text/javascript">
      jQuery(document).ready(function() {
        jQuery('<option>').val('shipped').text('<?php _e('Mark as Shipped')?>').appendTo("select[name='action']");
        jQuery('<option>').val('shipped').text('<?php _e('Mark as Shipped')?>').appendTo("select[name='action2']");
      });
    </script>
    <?php
  }
}

The last part is to add a function to it, like email the customer that his order is being shipped.

This is the content of the email that will be sent to the customer

function send_this($email) {

	$headers = 'From: My Store <noreply@mystore.com>' . "\r\n";
	$headers .= "MIME-Version: 1.0\r\n";
	$headers .= "Content-Type: text/html; charset=ISO-8859-1\r\n";
	
	$subject = 'Your Order has been shipped';

	$message = '<p><strong>Shipping Confirmation</strong><br />
	Your order has been shipped and is currently in transit.</p>
	<small>If you have not received your order in 7 business days, please send us an email at <a href="mailto:info@mystore.com">info@mystore.com</a></small>';	
	
	wp_mail( $email, $subject, $message, $headers ); 
}

This is the code that will update the order status.

function change_order_status($orderid) {
	$order = new WC_Order($orderid);
	$email = get_post_meta( $orderid, '_billing_email' )[0];
	if($order->status!='shipped') {
		$order->update_status('shipped', 'order_note');
		send_this($email);
	}
}

The function for the bulk actions.

add_action('load-edit.php', 'custom_bulk_action');
function custom_bulk_action() {
	global $typenow;
	$post_type = $typenow;
	$sendback = admin_url( "edit.php?post_type=$post_type&success=1" );
	
	if($post_type == 'shop_order') {
		$wp_list_table = _get_list_table('WP_Posts_List_Table');
		$action = $wp_list_table->current_action();
		$allowed_actions = array("shipped");
		if(!in_array($action, $allowed_actions)) return;
		
		if(isset($_REQUEST['post'])) {
			$orderids = array_map('intval', $_REQUEST['post']);
		}
		
		
		switch($action) {
			case "shipped":
				foreach( $orderids as $orderid ) {
					change_order_status($orderid);
				}
			break;
			default: return;
		}
		
		wp_redirect($sendback);
		exit();
	}
}

The function for saving the order status individually.

add_action( 'woocommerce_order_status_shipped', 'order_status_shipped_custom');
function order_status_shipped_custom($orderid) {
	change_order_status($orderid);
}

The function to display a successful message.

add_action('admin_notices', 'custom_bulk_admin_notices');
function custom_bulk_admin_notices() {
  global $post_type, $pagenow;
  if( $post_type == 'shop_order' && isset($_GET['success']) ) {
    echo '<div class="updated"><p>The orders have been successfully shipped!</p></div>';
  }
}

That’s it! You now have a new status in your woocommerce website!

Here’s the file you need to update.

app/design/frontend/[replacewithyourtemplate]/default</strong>/template/email/order/items/order/default.phtml

Find this code in that file

<?php $_item = $this->getItem() ?>
<?php $_order = $this->getItem()->getOrder() ?>

Then add this code below next to it.

<?php 
$productId = $_item->getProduct()->getId(); 
$product = Mage::getModel('catalog/product')->load($productId);
$attributes = $product->getAttributes(); // <--- load all the attribute of the product
$attribute_list = array('yourcustomattribute'); // <--- this is the product attirbute you want to display
?>

Then here’s the code that will display the custom attributes. You can place this anywhere you want it to display.

In my end, I place it below the SKU.

<?php 
foreach ($attributes as $attribute) {
    $attributeCode = $attribute->getAttributeCode();
    if(!in_array($attributeCode, $dispAttribs)) continue;
    $label = $attribute->getFrontend()->getLabel($product);
    $value = $attribute->getFrontend()->getValue($product);
    echo "<p><strong>".  $this->escapeHtml( $label ) .":</strong> " . $this->escapeHtml($value) . "</p>";
}
?>

You can also try this method instead of going through the code above, however you might encountered some issue but still worthy to experiment. In my end it did not displayed on an actual email but working on the test mail.

<p>
<strong>Attribute Label: </strong> 
<?php echo $this->escapeHtml($_item->getProduct()->getData('customattribute')); ?></p>

For convenience, I’ve included a source code for you to be able to test it without going through the actual purchase in magento.

Just create a file mailtest.php in your magento root directory.

<?php 
require_once 'app/Mage.php';
Mage::app();
// loads the proper email template
$emailTemplate  = Mage::getModel('core/email_template')->loadDefault('sales_email_order_template');

// All variables your error log tells you that are missing can be placed like this:
$emailTemplateVars = array();
$emailTemplateVars['usermessage'] = "blub";
$emailTemplateVars['store'] = Mage::app()->getStore();
$emailTemplateVars['sendername'] = 'sender name';
$emailTemplateVars['receivername'] = 'receiver name'; 

// order you want to load by ID
$id = isset($_GET['id']) ? $_GET['id'] : 1; // this is for you to select order dynamically by just adding id parameter
$emailTemplateVars['order'] = Mage::getModel('sales/order')->load($id); 

// load payment details:
// usually rendered by this template:
// web/app/design/frontend/base/default/template/payment/info/default.phtml
$order = $emailTemplateVars['order'];
$paymentBlock = Mage::helper('payment')->getInfoBlock($order->getPayment())->setIsSecureMode(true);
$paymentBlock->getMethod()->setStore(Mage::app()->getStore());  

$emailTemplateVars['payment_html'] = $paymentBlock->toHtml();

//displays the rendered email template
echo $emailTemplate->getProcessedTemplate($emailTemplateVars);

Now view the php file you’ve just created in the browser.

www.yourmagentosite.com/mailtest.php

This tutorial was applicable only to those who already have installed postgre on the server.

First is download the phppgadmin files

You can download it by cloning it in their repository

cd /path/to/your/www
git clone git://github.com/phppgadmin/phppgadmin.git pgadmin

Manual download is also available here http://phppgadmin.sourceforge.net/doku.php?id=download. Upload and extract it in your server.

Nex is to update the configuration

Copy the file config.inc.php-dist to config.inc.php from this directory /path/to/your/www/pgadmin/conf/

Open the config.inc.php you just copied, find and update this line of code

$conf['servers'][0]['host'] = '';

to

$conf['servers'][0]['host'] = 'localhost';

For instance that you have a different port then replace the default port 5432 to the one you have.

Now you can access and manage your database using it.

http://to_your_server/pgadmin

Just add these code snippets into theme’s functions.php

This is to make the woocommerce form to upload a file.

add_action('woocommerce_edit_account_form_tag',function(){
	echo ' enctype="multipart/form-data"';
});

Second is to add the upload photo field in the form.

add_action('woocommerce_edit_account_form_start',function(){
	?>
	<p><label for="photo">Photo</label><input type="file" id="photo" name="photo" /></p>
	<?php
});

Third is the function that will process to save the uploaded photo. Please note that you still need to add a validation to only accept image.

add_action('woocommerce_save_account_details',function( $user_id ){
	if ( ! function_exists( 'wp_handle_upload' ) ) {
	    require_once( ABSPATH . 'wp-admin/includes/file.php' );
	}
	$uploadedfile = $_FILES['photo'];
	$movefile = wp_handle_upload( $uploadedfile, array('test_form' => FALSE) );
	if ( $movefile && !isset( $movefile['error'] ) ) {
	  update_user_meta($user_id, 'avatar', $movefile['url']) 
	  or add_user_meta($user_id, 'avatar', $movefile['url']);
	} else {
	    echo $movefile['error'];
	}
});

Our final step is to overwrite the avatar using filter.

add_filter ('get_avatar', function($avatar_html, $id_or_email, $size, $default, $alt) {
	$avatar = get_user_meta($id_or_email,'avatar',true);
	if( $avatar ) {
		return '<img src="'.$avatar.'" width="96" height="96" alt="Avatar" class="avatar avatar-96 wp-user-avatar wp-user-avatar-96 photo avatar-default" />';
	} else {
		return $avatar_html;
	}
}, 10, 5);

That’s it! You have now an upload photo feature in your woocommerce website!

But let say you have a single page form with lots of textarea? One thing you could maybe do, is to make it look slick by adjusting the height of textarea a little smaller however, when user put long text in it, the textarea would probably have scrollbar. Would it be cool to have it automatically increase depending how long the text the user is trying to put?

Here's how you can do it.

Let's start with a basic textarea.

<textarea class="js-textarea-auto"></textarea>

And a sample css that sets the mininum height to the textarea.

.js-textarea-auto { min-height:50px; resize:none; overflow:hidden; }

Then lastly the jQuery

$('.js-textarea-auto').on('keyup',function(e){
	if( $(this).outerHeight() > $(this).prop('scrollHeight')) {
		$(this).outerHeight(5);
	}
	$(this).outerHeight($(this).prop('scrollHeight'));
});

Now if you're not using jquery, here’s a pure javascript you can use instead.

let textareas = document.querySelectorAll('.js-textarea-auto');
textareas.forEach(elm=>{
	elm.addEventListener('keyup', function(e){
		if( this.offsetHeight > this.scrollHeight) {
			this.style.height=`5px`;
		}
		this.style.height=`${this.scrollHeight}px`;
	})
})

Just add this in functions.php from the theme that is currently being used in wordpress.

First is to add a query variable which will be used later as identifier.

add_action('query_vars','set_query_var');
function set_query_var($vars) {
  array_push($vars, 'custom_page');
  return $vars;
}

Next is to add a custom rewrite rule, which will tells wordpress to add value to variable custom_page, when desired slug is visited, e.g. domain.com/custom

add_action('init', 'custom_add_rewrite_rule');
function custom_add_rewrite_rule(){
  add_rewrite_rule('^custom$','index.php?custom_page=1','top');
  flush_rewrite_rules(); // ideally, this one should be removed once everything is okay
}

Next is to change what template file to load whenever the variable custom_page is set.

add_filter('template_include', 'plugin_include_template');
function plugin_include_template($template){
  if(get_query_var('custom_page')){
  	$template = get_template_directory() ."/templates/custom.php";
  }    
  return $template;    
}

Then the last thing is to create the file inside the theme that you want to load, e.g [yourtheme]/templates/custom.php

That's it! Happy coding.

Since most of their products are grouped, finding a product they wanted to in a category is giving them a hard time. So they asked for another column where they can use to filter. In my case was to add product type column.

Sharing is caring so here’s how I did it.

The file that you need to modify for the category product is located in

/app/code/core/Mage/Adminhtml/Block/Catalog/Category/Tab/Product.php

Simply create a local copy of it, so that it will not be affected whenever magento is updated.

/app/code/local/Mage/Adminhtml/Block/Catalog/Category/Tab/Product.php

Now lets start editing this file.

Find _prepareCollection function and add this one line of code

->addAttributeToSelect('type_id')

add this next to price or in any order, doesn’t matter anyway

->addAttributeToSelect('sku')
->addAttributeToSelect('price')
->addAttributeToSelect('type_id')

Next is in the _prepareColumns function and add this piece of code

$this->addColumn('type',
array(
'header'=> Mage::helper('catalog')->__('Type'),
'width' => '120',
'index' => 'type_id',
'type' => 'options',
'options' => Mage::getSingleton('catalog/product_type')->getOptionArray(),
));

In my end I’ve added it next to

$this->addColumn('name', array(
	'header' => Mage::helper('catalog')->__('Name'),
	'index' => 'name'
));

After doing the steps above, just re-index your site to see the result.

From this

To this

That’s it! Happy coding.

To fix it, you just have to edit each product and set a default price, however given that it is coming from an API or other source, you might already have created hundred or thousand products.

So the easy solution was to set a default price through code, so it'll be applied to all products.

function wc_default_price($price) {
	if(empty($price) || $price == null || $price == "") {
		$price = 0;
	}
	return $price;
}

add_filter('woocommerce_get_price','wc_default_price', 10,1);

That's it! Product should now be purchasable.

Here's how you can customize the response of it.

Here in our example, we will be building a login/authentication restAPI so we will begin creating the files we're about to modify. Please note that our example focus mainly on how to override the response of formrequest and is not a fully functional login api.

LoginController

php artisan make:controller LoginController

LoginRequest

php artisan make:request LoginRequest

Now let's begin with LoginController.php located at app\Http\Controllers and replace the code using below.

<?php 
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller as BaseController;
use App\Http\Requests\LoginRequest;
class LoginController extends BaseController
{
    public function postLogin(LoginRequest $request) {
        return [
            'status' => true,
            'message' => 'Successfully logged in!'
        ];
    }
}
?>

Next is LoginRequest.php located at app\Http\Requests and use the code below.

<?php 
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Contracts\Validation\Validator;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Contracts\Hashing\Hasher;
use Illuminate\Validation\Factory as ValidationFactory;
class LoginRequest extends FormRequest
{
  protected function failedValidation(Validator $validator) { 
    throw new HttpResponseException(
      response()->json([
        'status' => false,
        'messages' => $validator->errors()->all()
      ], 401)
    ); 
  }
  public function authorize()
  {
      return true;
  }
  public function rules()
  {
      return [
          'username' => 'required',
          'password' => 'required'
      ];
  }
}
?>

The last part is add it to our route located at routes/web.php for new version of laravel app/Http/routes.php for older version.

Route::post('login', 'LoginController@postLogin');

And if you encounter an error while testing the login probably it's the csrf middleware laravel that causing it, just disable it by updating the file app/Http/Kernel.php by removing the code below.

\App\Http\Middleware\VerifyCsrfToken::class,

Here's the example result of what I did in postman by sending to the url without the username and password.

Happy coding!