tarsier-marianz

🔥 How to Create a Beautiful Custom Arrow Button in Flutter with Ripple Effect

2025-03-29T23:56:00.005+08:00

In this article, we'll walk you through how to build a custom button widget in Flutter that looks modern, stylish, and functional — similar to what you would see in fitness apps showing total calories burned.

We’ll add:

✅ Unique Arrow Clip Shape
✅ Smooth Rounded Corners
✅ Optional Gradient Background
✅ Proper Ripple Effect on tap
✅ Customizable content (title, icon, color, radius, etc).

Flutter provides great built-in buttons like ElevatedButton and TextButton, but sometimes you need a more visually appealing, app-specific component to match your design language.
This is exactly what we’ll achieve.

🛠️ How to Implement

1. Create an Arrow Clipper

We need to clip the left side of the button into an arrow shape:

class ArrowClipper extends CustomClipper<Path> {
  @override
  Path getClip(Size size) {
    double radius = 16;
    final path = Path();
    path.moveTo(0, radius);
    path.quadraticBezierTo(0, 0, radius, 0);
    path.lineTo(size.width * 0.80, 0);
    path.lineTo(size.width, size.height / 2);
    path.lineTo(size.width * 0.80, size.height);
    path.lineTo(radius, size.height);
    path.quadraticBezierTo(0, size.height, 0, size.height - radius);
    path.close();
    return path;
  }

  @override
  bool shouldReclip(covariant CustomClipper<Path> oldClipper) => false;
}

2. Build the Custom Button Widget

Here’s the full reusable CalorieButton widget:

import 'package:flutter/material.dart';

class CalorieButton extends StatelessWidget {
  final double value;
  final VoidCallback? onTap;
  final double borderRadius;
  final List<Color> gradientColors;
  final Color solidColor;
  final String title;
  final String? description;
  final IconData icon;
  final double height;
  final double width;

  const CalorieButton({
    super.key,
    required this.value,
    required this.onTap,
    this.borderRadius = 16,
    required this.gradientColors,
    this.solidColor = Colors.red,
    this.title = 'Total Calories',
    this.description = 'kCal',
    this.icon = LucideIcons.flame,
    this.height = 70,
    this.width = 250,
  });

  @override
  Widget build(BuildContext context) {
    return Material(
      color: Colors.white,
      elevation: 4,
      borderRadius: BorderRadius.circular(borderRadius),
      clipBehavior: Clip.antiAlias,
      child: InkWell(
        onTap: onTap,
        splashColor: gradientColors[0].withOpacity(0.2),
        child: SizedBox(
          height: height,
          width: width,
          child: Row(
            children: [
              // Left arrow shape
              ClipPath(
                clipper: ArrowClipper(),
                child: Container(
                  width: 80,
                  decoration: BoxDecoration(
                    gradient: LinearGradient(
                      colors: gradientColors!,
                      begin: Alignment.topLeft,
                      end: Alignment.bottomRight,
                    ),
                    //color: gradientColors == null ? solidColor : null,
                  ),
                  child: Center(
                    child: Icon(
                      icon,
                      color: Colors.white,
                      size: 28,
                    ),
                  ),
                ),
              ),

              const SizedBox(width: 16),

              // Text content
              Expanded(
                child: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      title,
                      style: TextStyle(
                        color: Colors.grey[600],
                        fontSize: 14,
                      ),
                    ),
                    const SizedBox(height: 4),
                    Text(
                      '$value',
                      style: TextStyle(
                        color: gradientColors[0],
                        fontSize: 20,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
                    const SizedBox(height: 2),
                    Text(
                      description ?? '',
                      style: const TextStyle(
                        color: Colors.grey,
                        fontSize: 12,
                      ),
                    ),
                  ],
                ),
              ),

              const Padding(
                padding: EdgeInsets.only(right: 16.0),
                child: Icon(
                  Icons.chevron_right,
                  color: Colors.grey,
                  size: 24,
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

3. Example Usage:

CalorieButton(
	value: 4800,
	title: 'Total Steps',
	description: 'Steps',
	icon: LucideIcons.footprints,
	onTap: () {},
	gradientColors: const [
	  Colors.red,
	  Color(0xFFcd2828),
	  Color(0xFF982121),
	  Color(0xFF761313),
	],
),

Creating a Laravel Command to Clear Log Files

2025-01-17T20:50:00.002+08:00

In this tutorial, we’ll create a custom Laravel console command to clean up old log files in the storage/logs directory, while preserving the .gitignore file. This is useful for maintaining a clean server and saving disk space.

Laravel logs application activities in the storage/logs directory. Over time, these logs can accumulate and occupy significant storage space. Deleting these files manually can be tedious, so we'll automate the process with a custom Artisan command.

Steps:

1. Generate the Console Command
Run the following Artisan command to create a new console command:

php artisan make:command ClearLogFiles

2. Edit the Command
Open the generated file located in app/Console/Commands/ClearLogFiles.php.

3. Update the Command Logic
Replace the contents of the file with the following:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\File;

class ClearLogFiles extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'logs:clear';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Clear all log files in storage/logs except .gitignore';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $logPath = storage_path('logs'); // Get the full path to the logs directory

        // Check if the logs directory exists
        if (!is_dir($logPath)) {
            $this->error('The logs directory does not exist.');
            return;
        }

        // Get all files in the logs directory
        $files = File::files($logPath);

        foreach ($files as $file) {
            // Skip the .gitignore file
            if ($file->getFilename() !== '.gitignore') {
                File::delete($file->getPathname()); // Delete the file
            }
        }

        $this->info('Log files cleared successfully, except .gitignore.');
    }
}

4. Register the Command (Optional)
Open app/Console/Kernel.php and add the command to the $commands array:

protected $commands = [
    \App\Console\Commands\ClearLogFiles::class,
];

5. Run the Command
Use the following Artisan command to clear the logs

php artisan logs:clear

Why Preserve `.gitignore`?

The .gitignore file is essential in projects using Git. It ensures the logs directory is excluded from version control while keeping the folder structure intact. Deleting it may cause unnecessary errors.

This command simplifies log management in your Laravel application, keeping your server clean and efficient.

How to Create and Publish a Dart/Flutter Package to pub.dev

2024-12-22T01:22:00.010+08:00

Creating and publishing a Dart/Flutter package to pub.dev allows you to share your code with the community. This guide will take you through the entire process step-by-step—from creating a package project to publishing it.

Step 1: Create a New Package

Using the Dart Command Line

Run the following command to create a new package:

dart create -t package-simple your_package_name

Replace your_package_name with the name of your package. In my case tarsier_logger is the name of my package. This command generates a new Dart package with a basic structure.

Using the Flutter Command Line (if it's a Flutter package)

For Flutter-specific packages, use:

flutter create --template=package your_package_name

Folder Structure

Your package folder will look like this:

your_package_name/
├── lib/
│   └── your_package_name.dart
├── test/
├── pubspec.yaml
├── README.md
├── CHANGELOG.md
├── LICENSE

Step 2: Implement Your Package Code

Edit the Main Library File

Open the lib/your_package_name.dart file and add your functionality. For example:

library your_package_name;

/// A simple utility to greet users.
class Greeter {
  final String name;

  Greeter(this.name);

  /// Returns a greeting message.
  String greet() => 'Hello, $name!';
}

This is where you build your package logic, classes, or widgets. In my created package tarsier_logger, this is what it looks like.

Step 3: Add Metadata in `pubspec.yaml`

Edit the pubspec.yaml file to include essential metadata:

name: your_package_name
description: A Dart/Flutter package for greeting users.
version: 1.0.0
homepage: https://github.com/yourusername/your_package_name
environment:
  sdk: ">=2.18.0 <3.0.0"

dependencies:
  # Add package dependencies here.

dev_dependencies:
  test: ^1.22.0

Key fields:

name: Unique package name.
description: A short summary of what your package does.
version: Start with 1.0.0 for new packages.
environment.sdk: Defines the compatible Dart SDK versions.

Step 4: Add Documentation

Create a `README.md` File

Write a clear and concise README.md that describes your package. Include usage examples, like this:

   # your_package_name

A Dart/Flutter package for greeting users.

## Usage

```dart
import 'package:your_package_name/your_package_name.dart';

void main() {
  var greeter = Greeter('Alice');
  print(greeter.greet()); // Output: Hello, Alice!
}

Add a CHANGELOG File

Contains the version and its changes. Example:

   ### Add a `CHANGELOG.md` File
Document changes for each version. Example:

```markdown

# CHANGELOG

## [1.0.0] - YYYY-MM-DD
### Added

- Initial release of the package.
- Added `Greeter` class for greeting users.

Add a `LICENSE` File

Use a standard open-source license like MIT. Example:

   MIT License
Copyright (c) 2024 Your Name

Step 5: Test Your Package

Write unit tests in the test folder. Example:

import 'package:your_package_name/your_package_name.dart';
import 'package:test/test.dart';

void main() {
  test('Greeter should return correct greeting', () {
    var greeter = Greeter('Alice');
    expect(greeter.greet(), 'Hello, Alice!');
  });
}

Run tests using:

dart test

Step 6: Prepare for Publishing

Verify Your Package

Run this command to check your package for potential issues:

dart pub publish --dry-run

dart pub publish -n

Fix any errors or warnings, such as missing README.md, CHANGELOG.md, or LICENSE files.

Format Your Code (Optional)

Ensure your code is properly formatted:

dart format .

Step 7: Publish Your Package

Authenticate with pub.dev

If this is your first time publishing, authenticate with pub.dev using:

dart pub login

In my case, I used Android Studio in development and already logged-in to my account so I am not required and no need to run the above command.

Publish Your Package

When ready, publish your package:

dart pub publish

Follow the prompts to confirm the upload.

Step 8: Verify on pub.dev

Once published, visit your package page on pub.dev:

https://pub.dev/packages/your_package_name

Check that:

The README.md renders correctly.
The documentation is clear and includes examples.
All metadata (description, license, version) is accurate.

🧰 pubspec_checker package for Flutter

2024-12-21T02:11:00.000+08:00

A simple Flutter package that checks the compatibility of all dependencies in the pubspec.yaml file for specified platforms. This package reads the pubspec.yaml file, fetches the package information from pub.dev, and verifies the platforms (like Android, iOS, web, macOS, Windows, and Linux) against the provided list.

Features

Platform Compatibility Check:
- Specify platforms (e.g., android, ios, web, etc.) to check which packages are supported.
Detailed Reporting:
- List all packages with their supported platforms. Optionally show package links for more details.
Easy to Use:
- Command-line arguments for quick execution and flexibility.

Getting started

Add pubspec_checker to your Flutter or Dart project:

dev_dependencies:
  pubspec_checker: ^1.0.0

Run this command:

flutter pub get

Usage

Command-Line Interface (CLI) To use the package, run the following command:

dart run pubspec_checker <platforms> [options]

Parameters

<platforms>: The platforms to check compatibility for. Supported values are:
- android
- ios
- web
- windows
- linux
- macos

Options

-s or --show: Display the list of packages with their supported platforms.
--l or --links: Display the links to the package details.

Examples

Check compatibility for android and ios:

dart run pubspec_checker android ios

Check compatibility for web:

dart run pubspec_checker web

dart run pubspec_checker:web

Example Output:

PS D:\Repository\pubspec_checker\example> dart run pubspec_checker windows ios
Building package executable...
Built pubspec_checker:pubspec_checker.
------- Started checking compatibility for "windows" -------
(2) Supported:
  ✅  file_picker
  ✅  connectivity_plus
(5) Not Supported:
  ❌  pusher_client
  ❌  disk_space
  ❌  open_file_plus
  ❌  sqflite_sqlcipher
  ❌  flutter_pdfview
------- Compatibility check completed for "windows" --------

Additional information

If you want to use the package programmatically, here’s how you can do it:

import 'package:pubspec_checker/pubspec_checker.dart';

void main() async {
  final checker = PlatformChecker(['ios', 'android']);
  final reader = PubspecReader();

  final dependencies = reader.getDependencies();
  final results = await checker.checkPackageCompatibility(dependencies);

  for (var package in results.entries) {
    print('Package: ${package.key}, Supported Platforms: ${package.value.join(", ")}');
  }
}

Contributing

Contributions are welcome! If you encounter any issues or have feature requests, please open an issue or submit a pull request on GitHub.

License

This package is licensed under the MIT License.

How to Create a Custom Dropdown Color Menu in Flutter

2024-12-16T01:30:00.094+08:00

Dropdown menus are a common UI component in Flutter, but sometimes you need something more personalized to fit your app’s design. This tutorial walks you through creating a custom dropdown color menu in Flutter. You’ll learn how to display color options in a dropdown and allow users to select one, with the selected color updating the UI dynamically.

Step 1: Setting Up the Flutter Project

1. Create a new Flutter project or open an existing one:

flutter create custom_dropdown_menu
cd custom_dropdown_menu

2. Open the project in your favorite IDE (e.g., VS Code or Android Studio).

Step 2: Building the Color Dropdown Menu

To create a dropdown menu that displays color options, we’ll use Flutter’s DropdownButton widget. However, we’ll customize it to show color swatches instead of regular text.

Code: Custom Dropdown Color Menu

Below is the full implementation:

import 'package:flutter/material.dart';

void main() {
  runApp(ColorDropdownApp());
}

class ColorDropdownApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: ColorDropdownScreen(),
    );
  }
}

class ColorDropdownScreen extends StatefulWidget {
  @override
  _ColorDropdownScreenState createState() => _ColorDropdownScreenState();
}

class _ColorDropdownScreenState extends State<ColorDropdownScreen> {
  // List of colors for the dropdown
  final List<Color> colors = [
    Colors.red,
    Colors.green,
    Colors.blue,
    Colors.yellow,
    Colors.purple,
    Colors.orange,
  ];

  // Currently selected color
  Color selectedColor = Colors.red;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Custom Dropdown Color Menu'),
        backgroundColor: selectedColor,
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              'Select a Color:',
              style: TextStyle(fontSize: 20),
            ),
            SizedBox(height: 20),
            // Dropdown Button
            DropdownButton<Color>(
              value: selectedColor,
              icon: Icon(Icons.arrow_drop_down),
              iconSize: 24,
              elevation: 16,
              dropdownColor: Colors.white,
              style: TextStyle(color: Colors.black),
              onChanged: (Color? newColor) {
                setState(() {
                  selectedColor = newColor!;
                });
              },
              items: colors.map<DropdownMenuItem<Color>>((Color color) {
                return DropdownMenuItem<Color>(
                  value: color,
                  child: Container(
                    width: 100,
                    height: 20,
                    color: color,
                  ),
                );
              }).toList(),
            ),
            SizedBox(height: 40),
            // Display selected color
            Text(
              'You selected:',
              style: TextStyle(fontSize: 18),
            ),
            Container(
              width: 100,
              height: 100,
              color: selectedColor,
            ),
          ],
        ),
      ),
    );
  }
}

Step 3: Running the Application

1. Save the code to main.dart.
2. Run the application

flutter run

Output

How It Works

1. DropdownButton Widget:

Displays a list of color options in a dropdown menu.
The DropdownButton widget has items, which is a list of DropdownMenuItem widgets. Each menu item contains a Container filled with a color swatch.

2. Dynamic State Update:

The onChanged callback updates the selectedColor variable whenever a new color is chosen, triggering a rebuild of the widget tree to reflect the updated color.

3. Selected Color Preview:

The selected color is displayed in a square box below the dropdown.

Code Enhancement

Let's enhance the custom dropdown menu to use a List<Map<String, dynamic>> instead of List<Color>. This allows us to associate a name with each color, making the menu more informative and flexible.

Updated Code: Custom Dropdown with Color Names

Here’s the enhanced version of the code:

import 'package:flutter/material.dart';

void main() {
  runApp(ColorDropdownApp());
}

class ColorDropdownApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: ColorDropdownScreen(),
    );
  }
}

class ColorDropdownScreen extends StatefulWidget {
  @override
  _ColorDropdownScreenState createState() => _ColorDropdownScreenState();
}

class _ColorDropdownScreenState extends State<ColorDropdownScreen> {
  // List of colors with names
  final List<Map<String, dynamic>> _colors = [
    {'name': 'Red', 'color': Colors.red},
    {'name': 'Green', 'color': Colors.green},
    {'name': 'Blue', 'color': Colors.blue},
    {'name': 'Yellow', 'color': Colors.yellow},
    {'name': 'Purple', 'color': Colors.purple},
    {'name': 'Orange', 'color': Colors.orange},
  ];

  // Currently selected color
  Map<String, dynamic> _selectedColor = {'name': 'Red', 'color': Colors.red};
  String _selectedColorName = 'Red';

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Enhanced Dropdown Color Menu'),
        backgroundColor: _selectedColor['color'],
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              'Select a Color:',
              style: TextStyle(fontSize: 20),
            ),
            SizedBox(height: 20),
            // Dropdown Button
            Container(
              // Set the background color of the container dynamically
              decoration: BoxDecoration(
                color: _selectedColor['color'],
                borderRadius: BorderRadius.circular(8.0),
              ),
              padding: EdgeInsets.symmetric(horizontal: 8.0),

              child: DropdownButtonHideUnderline(
                child: DropdownButton<String>(
                  // Define the dropdown items
                  items: _colors.map((colorMap) {
                    return DropdownMenuItem<String>(
                      value: colorMap['name'],
                      child: Row(
                        children: [
                          Container(
                            width: 20,
                            height: 20,
                            color: colorMap['color'], // Display color preview
                            margin: const EdgeInsets.only(right: 8),
                          ),
                          Text(colorMap['name']),
                        ],
                      ),
                    );
                  }).toList(),
                  // Hint text
                  hint: Text(
                    _selectedColorName,
                    style: TextStyle(color: Colors.white),
                  ),
                  onChanged: (String? selectedName) {
                    setState(() {
                      _selectedColorName = selectedName!;
                      // Update background color based on the selected color
                      _selectedColor = _colors.firstWhere((element) => element['name'] == selectedName);
                    });
                  },
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

Output of the enhanced code

Explanation of Enhancements

1. Using List<Map<String, dynamic>>:

Each color is represented as a map with name and color keys:

{'name': 'Red', 'color': Colors.red}

2. Updated _selectedColor State:

The dropdown now holds a map for the selected color:

Map<String, dynamic> _selectedColor = {'name': 'Red', 'color': Colors.red};

3. Wrapped DropdownButton with the container and removed the underline.

Once the selected color menu is changed then the container background will be updated.

Container(
  // Set the background color of the container dynamically
  decoration: BoxDecoration(
    color: _selectedColor['color'],
    borderRadius: BorderRadius.circular(8.0),
  ),
  padding: EdgeInsets.symmetric(horizontal: 8.0),
  child: DropdownButtonHideUnderline( child: ...),
),

4. Custom DropdownMenuItem:

Each menu item displays a small color swatch alongside the color name using a Row widget:

 return DropdownMenuItem<String>(
  value: colorMap['name'],
  child: Row(
	children: [
	  Container(
		width: 20,
		height: 20,
		color: colorMap['color'], // Display color preview
		margin: const EdgeInsets.only(right: 8),
	  ),
	  Text(colorMap['name']),
	],
  ),
);

5. Dynamic Updates:

When a new color is selected, the onChanged callback updates _selectedColor, triggering a UI refresh to reflect the selected color and its name.

How It Works

The dropdown uses the _colors list to generate menu items.
Each menu item is a combination of a color swatch and the color name.
When the user selects a color, the onChanged callback updates _selectedColor.
The app bar and the color preview box update dynamically based on the selected color.

This enhancement adds functionality and improves the user experience by displaying both color swatches and names in the dropdown menu. Using List<Map> makes the implementation more flexible and extendable. You can now easily add more properties (e.g., hex codes, descriptions) to the colors if needed.

You can explore the source code on the Github repository.

View on GitHub

How to Set Up Virtual Serial COM Ports Using com0com

2024-12-15T23:56:00.048+08:00

Virtual serial COM ports are essential for testing and debugging serial communication between software applications. com0com is a free, open-source virtual serial port emulator that allows you to create pairs of virtual COM ports that communicate with each other. This step-by-step tutorial will guide you through downloading, installing, and configuring com0com to set up virtual COM ports.

Step 1: Download com0com

1. Visit the official com0com project page on SourceForge or GitHub.
2. Download the latest version of com0com for your operating system.

Make sure to choose the correct version for your OS architecture (32-bit or 64-bit).

Step 2: Install com0com

1. Extract the downloaded zip file to a folder on your computer.
2. Open the extracted folder and locate the installer executable (setup_com0com_x64.exe for 64-bit systems or setup_com0com_x86.exe for 32-bit systems). setup_com0com_v3.0.0.0_W7_x64_signed.exe in my case.
3. Right-click the installer and select Run as Administrator.
4. Follow the installation wizard:

Accept the license agreement.
Choose the installation directory (default is recommended).
Click Install to complete the process.

5. After installation, you might see a driver installation prompt. Click Install or Allow to proceed with the virtual driver setup.

Step 3: Verify com0com Installation

1. Open the Device Manager:

Press Win + X and select Device Manager.

2. Expand the Ports (COM & LPT) section.
Look for devices labeled like com0com - bus for serial port pair. This confirms that com0com has been successfully installed.

Step 4: Configure Virtual COM Ports

com0com creates pairs of virtual COM ports that are interconnected. For example, data sent to COM10 will be received by COM11 and vice versa.

Using the GUI Configuration Tool

During installation, com0com may have installed a GUI tool named Virtual Null Modem. Launch it from the Start menu or in the desktop icon.

To create a new pair of virtual com ports click Add Pair button.

(Optional) Verify the added pair in Device Manager. (You can refer above Step 3: Verify com0com Installation).
Rename the port with your preferred port name.
Save the changes after renaming the ports by clicking Apply button.
(Optional) Verify whether the rename ports have been applied successfully.

Step 5: Test the Virtual COM Ports

Use any serial communication software (e.g., PuTTY, Tera Term, or HyperTerminal) to test the setup.
Open one instance of your terminal software and connect it to COM10.
Open another instance and connect it to COM11.
Send some data from one terminal. You should see the data appear on the other terminal, confirming successful communication between the virtual COM ports.

Using com0com to set up virtual serial COM ports is a simple yet powerful way to simulate and test serial communication between applications without requiring physical hardware. This method is invaluable for developers working on serial communication protocols, data logging, or hardware interfacing projects.

Interfacing Arduino L293D Driver with NPN Bipolar Transistor to Save Output Pins for Motor Direction Control

2024-12-15T22:09:00.007+08:00

Efficient utilization of microcontroller pins is crucial when working on Arduino projects, especially when pins are limited. A common scenario arises when controlling motor direction using an L293D motor driver. Typically, an H-bridge like the L293D requires two Arduino pins to control the motor's direction. However, with some ingenuity, we can reduce this to a single pin by integrating an NPN bipolar transistor.

This article explains how to interface the Arduino with an L293D motor driver and an NPN transistor to control motor direction while saving an output pin.

Understanding the L293D Motor Driver

The L293D is a dual H-bridge motor driver IC widely used for controlling DC motors and stepper motors. Each H-bridge requires two input pins from the Arduino to determine the direction of the motor, as shown below:

IN1 & IN2: Used to control the direction of Motor A.
IN3 & IN4: Used to control the direction of Motor B.

Standard Motor Direction Control:

Setting IN1 = HIGH and IN2 = LOW rotates the motor forward.
Setting IN1 = LOW and IN2 = HIGH rotates the motor backward.

The Problem

If you’re controlling multiple motors, the number of pins required can quickly add up, leaving fewer pins for other peripherals or sensors. For each motor, two Arduino pins are typically reserved for direction control.

The Solution: Using an NPN Transistor

We can save one Arduino pin per motor by using an NPN bipolar transistor as an electronic switch. The idea is to control one of the motor driver inputs (e.g., IN2) indirectly using the transistor while directly controlling the other (e.g., IN1) with the Arduino.

How It Works

One Arduino pin (D4) directly connects to IN1 of the L293D.
The second motor input, IN2, is connected to the collector of an NPN transistor.
The emitter of the transistor is connected to the ground.
A pull-down resistor ensures that the input to IN2 remains LOW when the transistor is off.
The base of the transistor is connected to the same Arduino pin as IN1 through a current-limiting resistor. This creates an inverted signal for IN2, ensuring complementary logic to IN1.

Logic Table

Arduino Pin (IN1)	Transistor (IN2)	Motor Direction
HIGH	LOW	Forward
LOW	HIGH	Reverse

Circuit Diagram

Here’s the schematic for interfacing an Arduino with an L293D motor driver and an NPN transistor:

Components Required:

Arduino Board (e.g., Uno or Nano)
L293D Motor Driver IC
NPN Bipolar Transistor (e.g., 2N2222 or BC547)
1 kΩ Resistor (for the transistor base)
10 kΩ Resistor (pull-down for IN2)
DC Motor
External Power Supply (if needed)

Code Implementation

Below is the Arduino code to control the motor direction with a single output pin:

#define MOTOR_PIN 4 // Define the pin controlling the motor
#define ENA_PIN  5;

void setup() {
  Serial.begin(9600);

  pinMode(MOTOR_PIN, OUTPUT);
  pinMode(ENA_PIN, OUTPUT);
}

void loop() {
  // Rotate motor forward
  digitalWrite(MOTOR_PIN, HIGH);
  delay(2000); // Run for 2 seconds
  
  // Rotate motor backward
  digitalWrite(MOTOR_PIN, LOW);
  delay(2000); // Run for 2 seconds
}

Working Explanation

When MOTOR_PIN is set to HIGH:
- IN1 receives a HIGH signal directly.
- IN2 is pulled LOW via the NPN transistor, creating a forward direction for the motor.
When MOTOR_PIN is set to LOW:
- IN1 receives a LOW signal directly.
- IN2 is set to HIGH through the pull-down resistor and the absence of base current in the transistor, creating a reverse direction for the motor.

This setup inverts the signal for IN2 using the transistor, eliminating the need for an additional Arduino pin.

Advantages of This Approach

1. Pin Efficiency: Each motor requires only one Arduino pin, freeing up more pins for other components.
2. Cost-Effective: NPN transistors are inexpensive and readily available.
3. Simple Logic: The complementary logic simplifies control without additional software complexity.
4. Scalability: Ideal for projects involving multiple motors and limited microcontroller pins.

By integrating an NPN bipolar transistor with the L293D motor driver, you can significantly optimize the use of Arduino pins in your motor control projects. This approach is particularly beneficial for applications where pin availability is limited but motor control functionality is essential. Try implementing this circuit in your next project to improve efficiency and scalability!

Joystick-605620: 3-Axis Joystick with Push Button

2024-12-08T22:06:00.000+08:00

is a simple Arduino-based application that demonstrates the use of a 3-axis joystick with an integrated push button. This project aims to provide hands-on experience in interfacing a joystick module with Arduino, showcasing how to read and process analog and digital signals from the joystick for various applications.

Objective

The primary goal of this project is to help beginners and hobbyists understand:

How to interface a 3-axis joystick module with Arduino.
Reading analog input from the joystick's axes (X, Y, and Z).
Detecting and processing button presses from the joystick's push button.

Features

Analog Input Reading: Demonstrates how to read analog signals from the joystick's X, Y, and Z axes using Arduino’s analog pins.
Push Button Detection: Explains how to configure a digital input pin to detect button presses.
Signal Processing: Provides examples of interpreting joystick inputs to control devices or navigate menus in Arduino applications.

Components Used

3-Axis Joystick Module (with push button).
Arduino Board (e.g., Uno, Nano, or Mega).
Resistors and jumper wires for connections.

Use Cases

This project serves as a foundation for developing more advanced applications, such as:

Remote control systems.
User input for robots or drones.
Custom controllers for gaming or navigation.

Disclaimer

This project is a basic demonstration intended for educational purposes and to inspire creativity. Users are encouraged to modify and expand the application for their specific needs.

Github Repository

View on GitHub

Troubleshooting Laravel Passport Migration Errors: "Table Already Exists"

2024-12-08T21:59:00.000+08:00

When setting up Laravel Passport for authentication, you might encounter migration issues during php artisan migrate. One common error is:

SQLSTATE[42S01]: Base table or view already exists: 1050 Table 'oauth_access_tokens' already exists

This error typically arises when the tables associated with Passport already exist in the database, causing a conflict during migration.

The Problem

The Laravel migration process tries to create tables such as:

oauth_auth_codes
oauth_access_tokens
oauth_clients
oauth_personal_access_clients
oauth_refresh_tokens

If any of these tables already exist in your database, the migration process will fail.

Solution

To resolve this issue, follow these steps:

1. Identify Existing Tables

Check if the following Passport-related tables already exist in your database:

oauth_auth_codes
oauth_access_tokens
oauth_clients
oauth_personal_access_clients
oauth_refresh_tokens

You can do this using a database management tool like phpMyAdmin or through the MySQL command line.

2. Remove Existing Tables

If the tables exist, you can remove them manually or run the following SQL query in your database query editor:

SET FOREIGN_KEY_CHECKS = 0;
DROP TABLE IF EXISTS database_name.oauth_auth_codes;
DROP TABLE IF EXISTS database_name.oauth_access_tokens;
DROP TABLE IF EXISTS database_name.oauth_clients;
DROP TABLE IF EXISTS database_name.oauth_personal_access_clients;
DROP TABLE IF EXISTS database_name.oauth_refresh_tokens;
SET FOREIGN_KEY_CHECKS = 1;

Note: Replace database_name with the actual name of your database.

This will delete all the Passport-related tables, bypassing any foreign key constraints.

**3. Clear Migration Cache (Optional)**

If the migration records still persist in the migrations table, clear them to ensure a clean migration process. Run the following query:

DELETE FROM migrations WHERE migration LIKE '%oauth%';

4. Re-run Laravel Migrations

After clearing the tables, run the migration command again:

php artisan migrate

This will recreate all Passport-related tables in your database.

Why Does This Happen?

The error occurs if:

1. The Passport tables already exist in the database due to a previous migration or manual table creation.
2. A database restore or rollback was incomplete, leaving behind residual tables.

Troubleshooting: This version of npm is compatible with lockfileVersion@1

2024-12-08T07:32:00.005+08:00

When installing the laravel-echo and pusher-js packages. This issue arises because the version of npm being used is incompatible with the lockfile version specified in your package-lock.json file. Let’s dive into a detailed explanation and the solution:

Error:

This version of npm is compatible with lockfileVersion@1, but package-lock.json was generated for lockfileVersion@0. I'll try to do my best with it!

This error typically occurs when you use an updated version of npm that expects package-lock.json files to have lockfileVersion set to 1, but the existing package-lock.json file is based on an earlier version (e.g., 0).

Steps to Fix the Issue:

1. Delete the Existing `package-lock.json` File

The package-lock.json file locks dependencies to specific versions for consistency. However, if it's outdated or corrupted, it can cause compatibility issues. Delete it by running:

rm package-lock.json

Alternatively, manually locate and delete the file in your project directory.

2. Clear npm Cache

To ensure no cached data interferes with the installation process, clear the npm cache:

npm cache clean --force

Note: Adding the --force flag ensures the cache is cleaned, even if warnings arise. However, use it cautiously to avoid unintended side effects.

3. Reinstall the Dependencies

Run the command again to install the required packages:

npm install --save laravel-echo pusher-js

The --save flag ensures that the dependencies are added to your dependencies section in package.json.

4. Verify Success

Once the installation completes, check the node_modules directory to confirm that laravel-echo and pusher-js have been installed correctly.

Why Does This Happen?

This issue occurs due to differences in lockfileVersion:

lockfileVersion@0: Used in older npm versions (e.g., npm@5).
lockfileVersion@1: Introduced in npm@6, offering improved reliability and consistency.

If your npm version is updated but your package-lock.json file is still using the older format, conflicts arise.

Troubleshooting: The server requested authentication method unknown to the client

2024-12-08T06:51:00.029+08:00

The server requested authentication method unknown to the client

The cause of this is MySQL v8.0+, it changes the default method to authentication of the database. Therefore, you need to get your hand on the MySQL server to fix it.

METHOD 1. Run this query to your MySQL query editor or you can run it in CLI.

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

METHOD 2. Change MySQL server configuration to use a native password as the default method for authentication. In my case, I used laragon and it can be found C:\laragon\bin\mysql\mysql-<version>\my.ini. find the [mysqld] section and add the following line:

[mysqld]
default_authentication_plugin = mysql_native_password

Then restart MySQL server.

Flutter: Gradient rounded button

2024-11-22T11:05:00.004+08:00

To create a gradient rounded button, we will use the Container widget with a BoxDecoration that includes both a LinearGradient for the background color and BorderRadius for the rounded corners. Wrap this Container inside a GestureDetector or InkWell to make it respond to touch events.

Here’s a code snippet for our stateless widget (gradient_rounded_button.dart):

import 'package:flutter/material.dart';

class GradientRoundedButton extends StatelessWidget {
  final double borderRadius;
  final String text;
  final List<Color> gradientColors;
  final VoidCallback onPressed;

  const GradientRoundedButton({
    required this.text,
    required this.gradientColors,
    required this.onPressed,
    this.borderRadius = 30,
  });

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: onPressed,
      child: Container(
        padding: EdgeInsets.symmetric(vertical: 15, horizontal: 30),
        decoration: BoxDecoration(
          gradient: LinearGradient(
            colors: gradientColors,
            begin: Alignment.topLeft,
            end: Alignment.bottomRight,
          ),
          borderRadius: BorderRadius.circular(borderRadius),
          boxShadow: [
            BoxShadow(
              color: gradientColors.last.withOpacity(0.5),
              offset: Offset(0, 4),
              blurRadius: 10,
            ),
          ],
        ),
        child: Center(
          child: Text(
            text,
            style: TextStyle(
              color: Colors.white,
              fontSize: 16,
              fontWeight: FontWeight.bold,
            ),
          ),
        ),
      ),
    );
  }
}

Explanation of important keys to make this widget

1. Gradient: The BoxDecoration uses a LinearGradient to apply a gradient effect with gradientColors, which you can customize by passing a list of colors.
2. Rounded Corners: The borderRadius property of BoxDecoration rounds the corners. Adjust the BorderRadius.circular value to change the level of roundness.
3. Shadow: The boxShadow property adds a subtle shadow effect, using the last color in gradientColors for a cohesive look.
4. Text and Gesture: The GestureDetector wraps the Container, making the button tappable. Text styling is applied for better readability over the gradient background.

Usage of the widget

In the code above, the GradientRoundedButton widget is reusable. Pass the text, gradient colors, borderRadius , and an onPressed callback to create multiple gradient buttons with different styles. Here is an example on how to use the widget (main.dart).

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: GradientRoundedButtonDemo(),
    );
  }
}

class GradientRoundedButtonDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Gradient Rounded Button"),
      ),
      body: Center(
        child: GradientRoundedButton(
          text: "PressMe",
          gradientColors: [Colors.blue, Colors.purple],
          onPressed: () {
            print("Button Pressed!");
          },
        ),
      ),
    );
  }
}

(Hmmmm...) This is the sample result of the above code.

The output sample above does not give users feedback when the user interacts with the UI. We need to enhance the widget we created to make the button feel more responsive and polished. And, in the current state of the button we need to wrap it with the other widget to define the width and height.

By adding hover effects, as well as specifying the width and height for buttons, we can enhance the user interface, especially in applications where user interaction is essential, such as on desktops or web platforms. Here’s why these additions are beneficial:

1. Hover Effects

Improved User Experience: Hover effects give users feedback when they interact with UI elements, making the application feel more responsive and polished.
Visual Cue: Hovering can signal to the user that the element is clickable or interactive, which is particularly important on larger screens (like desktop and web) where the pointer is used.
Aesthetic Appeal: Transitioning colors or shadows when hovering can add a level of visual sophistication, making the app feel more engaging and modern.

In Flutter, hover effects are especially relevant when building apps that run on desktops or web, where the user interacts with the UI via a mouse or trackpad rather than just touch.

2. Width and Height

Consistent Button Size: Specifying width and height ensures the button remains consistent in size across different screens or layouts. Without set dimensions, the button might resize based on its content, leading to a less uniform appearance.
Layout Control: Setting dimensions allows you to control the exact placement and alignment of the button within its parent container, giving you more control over the overall layout.
Responsive Design: On larger screens, having specific dimensions prevents UI elements from looking disproportionately small or large. You can also make the dimensions responsive to adapt to different screen sizes (e.g., by using MediaQuery to set the size based on screen dimensions).

Updated Code Example with Hover Effects, and Width and Height

Here’s an updated code (gradient_rounded_button.dart) that includes hover colors, and width and height for the button:

class GradientRoundedButton extends StatefulWidget {
  final double? width;
  final double? height;
  final String text;
  final List<Color> gradientColors;
  final List<Color> hoverGradientColors;
  final VoidCallback onPressed;

  const GradientRoundedButton({
    required this.text,
    required this.gradientColors,
    required this.hoverGradientColors,
    required this.onPressed,
    this.width,
    this.height,
  });

  @override
  _GradientRoundedButtonState createState() => _GradientRoundedButtonState();
}

class _GradientRoundedButtonState extends State<GradientRoundedButton> {
  bool _isHovered = false;

  @override
  Widget build(BuildContext context) {
    return MouseRegion(
      onEnter: (_) {
        setState(() {
          _isHovered = true;
        });
      },
      onExit: (_) {
        setState(() {
          _isHovered = false;
        });
      },
      child: GestureDetector(
        onTap: widget.onPressed,
        child: AnimatedContainer(
          width: widget.width,
          height: widget.height ?? 50,
          duration: Duration(milliseconds: 200),
          padding: EdgeInsets.symmetric(vertical: 15, horizontal: 30),
          decoration: BoxDecoration(
            gradient: LinearGradient(
              colors: _isHovered ? widget.hoverGradientColors : widget.gradientColors,
              begin: Alignment.topLeft,
              end: Alignment.bottomRight,
            ),
            borderRadius: BorderRadius.circular(30),
            boxShadow: [
              BoxShadow(
                color: (_isHovered ? widget.hoverGradientColors.last : widget.gradientColors.last).withOpacity(0.5),
                offset: Offset(0, 4),
                blurRadius: 10,
              ),
            ],
          ),
          child: Center(
            child: Text(
              widget.text,
              style: TextStyle(
                color: Colors.white,
                fontSize: 16,
                fontWeight: FontWeight.bold,
              ),
            ),
          ),
        ),
      ),
    );
  }
}

As we can see in the updated codes, we changed from StatelessWidget into StatefulWidget and added some properties for hoverGradientColors , and width /height . And wrap it with MouseRegion with a core functions onEnter and onExit that handles the changes of the hover state.

Explanation of the changes

1. MouseRegion Widget:

Wraps the button to detect mouse enter and exit events.
onEnter sets _isHovered to true, and onExit sets it to false.

2. AnimatedContainer:

Used to smoothly animate the gradient color change when hovering.
The duration property specifies the animation duration for the hover effect.

3. Gradient Colors on Hover:

When _isHovered is true, widget.hoverGradientColors is used for the gradient.
When _isHovered is false, the default widget.gradientColors is used.

4. Hover Shadow:

Adjusts the shadow color based on whether the button is hovered, creating a subtle shadow effect that changes with the gradient.

Usage of the changes

In this example, you specify both the normal gradient colors (gradientColors) and the hover gradient colors (hoverGradientColors) when creating the GradientRoundedButton. Now, when you hover over the button, it will smoothly transition to the hover gradient colors. Adjust the colors as needed for your desired hover effect.

Here is the example of the updated code for (main.dart).

class GradientRoundedButtonDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Gradient Rounded Button"),
      ),
      body: Center(
        child: GradientRoundedButton(
          width: 200,
          text: "Press Me",
          gradientColors: [Colors.blue, Colors.purple],
          hoverGradientColors: [Colors.purple, Colors.blue],
          onPressed: () {
            // Handle button press
            print("Button Pressed!");
          },
        ),
      ),
    );
  }
}

The final result of our changes.

With these adjustments, the button will have a consistent size and a responsive hover effect, making it well-suited for web or desktop applications. You can modify width and height values as needed or even make them responsive based on the screen size.

Building a REST API Client in Java with Swing

2024-11-13T12:38:00.003+08:00

In this tutorial, we’ll walk through creating a REST API client in Java using the Swing library. This client will interact with a REST API server to manage product data. We'll cover CRUD (Create, Read, Update, Delete) operations, and focus on building a simple graphical interface to make these actions user-friendly.

Prerequisites

To follow this tutorial, it’s recommended that you review our previous article on building a REST API server with PHP, where we implemented basic CRUD endpoints for managing products and categories. Additionally, we previously created articles building a REST API Client in C# with Windows Form and building a REST API Client in Python with PyQt5, which can serve as a helpful comparison.

Project Overview

Our Java Swing client will perform these actions:

Retrieve and display a list of products
Add new products
Update existing products
Delete products

For this, we'll use Java's HttpURLConnection for making HTTP requests and Swing components for the UI.

Setting Up the Java Project

Create a New Java Project in your IDE of choice.
Add any necessary imports for HttpURLConnection, JSON parsing (org.json), and Swing components.

Complete Code Implementation

Below is a basic setup for the Swing client, with each CRUD operation explained.

Main Java Swing Client Class

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONArray;
import org.json.JSONObject;

public class ProductAPIClient extends JFrame {

    private JTextField nameField, descriptionField;
    private JTextField priceField;
    private JButton createButton, fetchButton, updateButton, deleteButton;
    private JTable productTable;
    private DefaultTableModel tableModel;

    //private static final String API_BASE_URL = "http://localhost:8000/api/products";
    private static final String API_BASE_URL = "https://bcssti.com/api-sample/products";

    public ProductAPIClient() {
        setTitle("Product API Client");
        setSize(600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());

        nameField = new JTextField(10);
        descriptionField = new JTextField(15);
        priceField = new JTextField(5);
        createButton = new JButton("Create Product");
        fetchButton = new JButton("Get All Products");
        updateButton = new JButton("Update Product");
        deleteButton = new JButton("Delete Product");

        // Set up table model and JTable
        tableModel = new DefaultTableModel(new String[]{"ID", "Name", "Description", "Price"}, 0);
        productTable = new JTable(tableModel);
        productTable.setPreferredScrollableViewportSize(new Dimension(550, 200));
        JScrollPane scrollPane = new JScrollPane(productTable);

        add(new JLabel("Name:"));
        add(nameField);
        add(new JLabel("Description:"));
        add(descriptionField);
        add(new JLabel("Price:"));
        add(priceField);
        add(createButton);
        add(fetchButton);
        add(updateButton);
        add(deleteButton);
        add(scrollPane);

        createButton.addActionListener(e -> createProduct(nameField.getText(), descriptionField.getText(), priceField.getText()));
        fetchButton.addActionListener(e -> getAllProducts());
        updateButton.addActionListener(e -> updateProduct(nameField.getText(), descriptionField.getText(), priceField.getText()));
        deleteButton.addActionListener(e -> deleteProduct(nameField.getText()));
    }

    private void createProduct(String name, String description, String price) {
        try {
            JSONObject jsonInput = new JSONObject();
            jsonInput.put("name", name);
            jsonInput.put("description", description);
            jsonInput.put("price", Double.parseDouble(price));

            URL url = new URL(API_BASE_URL + "/");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Accept", "application/json");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Cache-Control", "no-cache");
            conn.setDoOutput(true);

            try (OutputStream os = conn.getOutputStream()) {
                System.out.println(jsonInput.toString());
                byte[] input = jsonInput.toString().getBytes("utf-8");
                os.write(input, 0, input.length);
                os.flush();
            }

            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                JOptionPane.showMessageDialog(this, "Product created successfully.");
                this.getAllProducts();
            } else {
                JOptionPane.showMessageDialog(this, "Failed to create product: " + responseCode);
            }
            conn.disconnect();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Error: " + e.getMessage());
        }
    }

    private void getAllProducts() {
        try {
            URL url = new URL(API_BASE_URL);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Cache-Control", "no-cache");

            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String inputLine;
            StringBuilder content = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                content.append(inputLine);
            }
            in.close();
            conn.disconnect();

            JSONArray products = new JSONArray(content.toString());

            // Clear existing rows in the table model
            tableModel.setRowCount(0);

            // Populate the JTable with data
            for (int i = 0; i < products.length(); i++) {
                JSONObject product = products.getJSONObject(i);
                int id = product.getInt("id");
                String name = product.getString("name");
                String description = product.getString("description");
                double price = product.getDouble("price");
                tableModel.addRow(new Object[]{id, name, description, price});
            }
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Error: " + e.getMessage());
        }
    }

    private void updateProduct(String name, String description, String price) {
        try {
            int productId = Integer.parseInt(JOptionPane.showInputDialog("Enter Product ID to Update"));
            JSONObject jsonInput = new JSONObject();
            jsonInput.put("name", name);
            jsonInput.put("description", description);
            jsonInput.put("price", Double.parseDouble(price));

            URL url = new URL(API_BASE_URL + "?id=" + productId);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("PUT");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Cache-Control", "no-cache");
            conn.setDoOutput(true);

            try (OutputStream os = conn.getOutputStream()) {
                os.write(jsonInput.toString().getBytes());
                os.flush();
            }

            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                JOptionPane.showMessageDialog(this, "Product updated successfully.");
                this.getAllProducts();
            } else {
                JOptionPane.showMessageDialog(this, "Failed to update product: " + responseCode);
            }
            conn.disconnect();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Error: " + e.getMessage());
        }
    }

    private void deleteProduct(String name) {
        try {
            int productId = Integer.parseInt(JOptionPane.showInputDialog("Enter Product ID to Delete"));
            String urlPath = API_BASE_URL + "?id=" + productId;
            URL url = new URL(urlPath);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("DELETE");
            conn.setRequestProperty("Cache-Control", "no-cache");

            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                JOptionPane.showMessageDialog(this, "Product deleted successfully.");
                this.getAllProducts();
            } else {
                JOptionPane.showMessageDialog(this, "Failed to delete product: " + responseCode + "\n" + urlPath);
            }
            conn.disconnect();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Error: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            ProductAPIClient client = new ProductAPIClient();
            client.setVisible(true);
        });
    }
}

Explanation of Key Sections

1. Setting Up HTTP Requests with `HttpURLConnection`

In the createProduct method, we use HttpURLConnection to set up a connection to our API:

HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", "application/json");
conn.setRequestProperty("Cache-Control", "no-cache");
conn.setDoOutput(true);

Here we use Cache-Control: no-cache to ensure that the request bypasses any local or proxy cache, so the client always gets the latest response directly from the server.

2. JSON Payload Construction and Transmission

Using org.json.JSONObject, we create the JSON payload for our product:

JSONObject jsonInput = new JSONObject();
jsonInput.put("name", name);
jsonInput.put("description", description);
jsonInput.put("price", Double.parseDouble(price));

After preparing the JSON object, we convert it to a byte array and send it to the server using OutputStream.

3. Handling Server Responses

We check the response code to confirm if the creation was successful:

int responseCode = conn.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
	JOptionPane.showMessageDialog(this, "Product created successfully.");
	this.getAllProducts();
} else {
	JOptionPane.showMessageDialog(this, "Failed to create product: " + responseCode);
}

This feedback informs the user of the result and makes troubleshooting easier.

Wrapping Up

In this article, we developed a basic Java client to interact with a REST API. This client enables CRUD operations on products and uses essential headers to manage data freshness and consistency. You can further enhance this client by:

Adding error handling and input validation
Creating a more advanced GUI layout
Implementing additional API endpoints like categories

Additional Resources

Server-side REST API tutorial from our previous article.
C# REST API Client and Python REST API Client were built previously, showing another approach for interacting with the API with different language.
A downloadable Postman collection for testing the API directly.

By following this guide, you’ll have a fully functional Java Swing client ready to manage product data in a RESTful environment

Building a REST API Client in Flutter and Dart

2024-11-13T12:37:00.018+08:00

In this tutorial, we’ll create a Flutter application that performs CRUD (Create, Read, Update, Delete) operations on a REST API. This app will interact with a backend API to manage product data, demonstrating the basics of HTTP requests, handling responses, and updating UI components.

Prerequisites

1. Flutter Setup: Ensure Flutter is installed and set up.
2. API Ready: You should have a REST API server set up. (If not, you can check out our previous tutorial on setting up a server-side API with PHP as a prerequisite.)
3. Dependencies: Install the http package in pubspec.yaml to make HTTP requests.

dependencies:
  flutter:
    sdk: flutter
  http: ^0.13.0

Step 1: Setting Up the Model

To manage products in our Flutter app, let’s create a model class that will represent a product entity.

// models/product.dart
class Product {
  final int id;
  final String name;
  final String description;
  final double price;

  Product({required this.id, required this.name, required this.description, required this.price});

  // Factory method to create a Product from JSON
  factory Product.fromJson(Map<String, dynamic> json) {
    return Product(
      id: json['id'] ?? 0,
      name: json['name'],
      description: json['description'],
      price: double.tryParse(json['price']) ?? 0.0,
    );
  }

  // Method to convert a Product instance to JSON
  Map<String, dynamic> toJson() {
    return {
      'name': name,
      'description': description,
      'price': price,
    };
  }
}

Step 2: Implementing the CRUD Operations

We’ll create a ProductService class to handle the HTTP requests. Each function will correspond to a CRUD operation.

// services/product_service.dart
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../models/product.dart';

class ProductService {
  //static const String apiUrl = 'http://localhost:8000/api/products';
  static const String apiUrl = 'https://bcssti.com/api-sample/products/';

  // GET: Fetch all products
  Future<List<Product>> getAllProducts() async {
    final response = await http.get(Uri.parse(apiUrl), headers: {
      'Cache-Control': 'no-cache',
    });

    if (response.statusCode == 200) {
      List jsonResponse = json.decode(response.body);
      return jsonResponse.map((data) => Product.fromJson(data)).toList();
    } else {
      throw Exception('Failed to load products');
    }
  }

  // POST: Add a new product
  Future<Product> createProduct(String name, String description, double price) async {
    final response = await http.post(
      Uri.parse(apiUrl),
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'no-cache',
      },
      body: json.encode({'name': name, 'description': description, 'price': price}),
    );

    if (response.statusCode == 200) {
      return Product.fromJson(json.decode(response.body));
    } else {
      throw Exception('Failed to create product');
    }
  }

  // PUT: Update a product by ID
  Future<Product> updateProduct(int id, String name, String description, double price) async {
    final response = await http.put(
      Uri.parse('$apiUrl?id=$id'),
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'no-cache',
      },
      body: json.encode({'name': name, 'description': description, 'price': price}),
    );

    if (response.statusCode == 200) {
      return Product.fromJson(json.decode(response.body));
    } else {
      throw Exception('Failed to update product');
    }
  }

  // DELETE: Remove a product by ID
  Future<void> deleteProduct(int id) async {
    final response = await http.delete(
      Uri.parse('$apiUrl?id=$id'),
      headers: {
        'Cache-Control': 'no-cache',
      },
    );

    if (response.statusCode != 200) {
      throw Exception('Failed to delete product');
    }
  }
}

Step 3: Setting Up the UI

In the UI, we’ll add buttons to perform each operation (Fetch, Create, Update, and Delete) and display the products in a list.

// main.dart
import 'package:flutter/material.dart';
import 'models/product.dart';
import 'services/product_service.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Product API Client',
      home: ProductListScreen(),
    );
  }
}

class ProductListScreen extends StatefulWidget {
  @override
  _ProductListScreenState createState() => _ProductListScreenState();
}

class _ProductListScreenState extends State<ProductListScreen> {
  final ProductService productService = ProductService();
  List<Product> products = [];

  @override
  void initState() {
    super.initState();
    _fetchProducts();
  }

  void _fetchProducts() async {
    final fetchedProducts = await productService.getAllProducts();
    setState(() {
      products = fetchedProducts;
    });
  }

  void _createProduct(String name, String description, double price) async {
    await productService.createProduct(name, description, price);
    _fetchProducts();
  }

  void _updateProduct(int id, String name, String description, double price) async {
    await productService.updateProduct(id, name, description, price);
    _fetchProducts();
  }

  void _deleteProduct(int id) async {
    await productService.deleteProduct(id);
    _fetchProducts();
  }

  void _showDialog(Product product, bool add) {

    final nameController = TextEditingController(text: product.name);
    final descriptionController = TextEditingController(text: product.description);
    final priceController = TextEditingController(text: product.price.toString());

    showDialog(
      context: context,
      builder: (context) {
        return AlertDialog(
          title: Text('Update Product'),
          content: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              TextField(
                controller: nameController,
                decoration: InputDecoration(labelText: 'Name'),
              ),
              TextField(
                controller: descriptionController,
                decoration: InputDecoration(labelText: 'Description'),
              ),
              TextField(
                controller: priceController,
                decoration: InputDecoration(labelText: 'Price'),
                keyboardType: TextInputType.number,
              ),
            ],
          ),
          actions: [
            TextButton(
              onPressed: () {
                Navigator.of(context).pop();
              },
              child: Text('Cancel'),
            ),
            TextButton(
              onPressed: () {
                final name = nameController.text;
                final description = descriptionController.text;
                final price = double.tryParse(priceController.text) ?? product.price;
                if (add) {
                  _createProduct(name, description, price);
                } else {
                  _updateProduct(product.id, name, description, price);
                }
                Navigator.of(context).pop();
              },
              child: Text(add ? 'Add' : 'Update'),
            ),
          ],
        );
      },
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Products API Client')),
      body: ListView.builder(
        itemCount: products.length,
        itemBuilder: (context, index) {
          final product = products[index];
          return ListTile(
            title: Text(product.name),
            subtitle: Text(product.price.toStringAsFixed(2)),
            trailing: IconButton(
              icon: const Icon(Icons.delete),
              onPressed: () => _deleteProduct(product.id),
            ),
            onTap: () => _showDialog(product, false),
          );
        },
      ),
      floatingActionButton: FloatingActionButton(
        child: const Icon(Icons.add),
        onPressed: () => _showDialog(Product(id: 0, name: '', description: '', price: 0), true),
      ),
    );
  }
}

Explanation of CRUD Functions in Flutter

   1. Fetch Products (getAllProducts): The getAllProducts method retrieves all products from the API using a GET request. We parsed the JSON response and updated the products list in the UI.
   2. Create Product (createProduct): The createProduct method sends a POST request with a JSON body containing product data. Once created, the product list is refreshed.
   3. Update Product (updateProduct): This method sends a PUT request with updated product details. After successfully updating, the UI is refreshed to show the latest data.
   4. Delete Product (deleteProduct): The deleteProduct method uses a DELETE request to remove a product by ID. The UI is refreshed after deletion.

Additional Resources

Server-side REST API tutorial from our previous article.
C# REST API Client , Python REST API Client and Java REST API Client were built previously, showing another approach for interacting with the API with different language.
A downloadable Postman collection for testing the API directly.

With this setup, you’ve built a simple and complete CRUD-enabled Flutter app that interacts with a REST API. This tutorial provides a solid foundation for handling data in Flutter with an HTTP-based backend

Building a REST API Client in Python with PyQt5

2024-11-13T06:28:00.009+08:00

In this tutorial, we’ll explore how to build a Python-based GUI client using PyQt5 to interact with a REST API. We’ll cover the complete implementation of basic CRUD operations and explain key considerations for RESTful API interaction, including the use of headers like Cache-Control.

Prerequisites

Before diving into the PyQt5 client, you’ll want to ensure you’ve followed the setup in the previous article on building a REST API with native PHP (link to prior blog), where we set up endpoints to handle product and category data. Additionally, we created a C# client for the same API, which you can review here from the previous article Building a REST API Client in C# with Windows Form to gain insights into other approaches for interacting with REST APIs.

Overview of the Project

This client will allow us to:

Retrieve and display product lists from the server
Add new products
Update existing product information
Delete products

Our PyQt5 client will communicate with our REST API server using Python’s requests library, and it will leverage Qt widgets for user interface components.

Setting Up the API Client

Step 1: Install Dependencies

If you haven’t already, install PyQt5 and the requests library:

pip install PyQt5 requests

Step 2: Code for the PyQt5 API Client

Below is a simplified structure for the PyQt5 client. Here’s how it’s set up:

Retrieve Products: Get a list of all products from the API.
Create Product: Add a new product.
Update Product: Modify an existing product.
Delete Product: Remove a product from the list.

Complete Source Code Implementation

import sys

import requests
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLineEdit, QMessageBox, \
    QFormLayout, QTableWidget, QTableWidgetItem, QHeaderView

# API_BASE_URL = 'http://localhost:5000'  # Replace with your API URL
API_BASE_URL = 'https://bcssti.com/api-sample'
HEADERS = {
    'Cache-Control': 'no-cache',
    'Content-type': 'application/json',
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'
}


class ApiClientApp(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Product API Client")
        self.setGeometry(100, 100, 600, 400)

        self.layout = QVBoxLayout()

        # Form layout for input fields
        self.formLayout = QFormLayout()
        self.productIdInput = QLineEdit()
        self.productNameInput = QLineEdit()
        self.descriptionInput = QLineEdit()
        self.productPriceInput = QLineEdit()

        self.formLayout.addRow("ID:", self.productIdInput)
        self.formLayout.addRow("Name:", self.productNameInput)
        self.formLayout.addRow("Description:", self.descriptionInput)
        self.formLayout.addRow("Price:", self.productPriceInput)

        self.layout.addLayout(self.formLayout)

        # Buttons
        self.getAllButton = QPushButton("Get All Products")
        self.getButton = QPushButton("Get Product")
        self.createButton = QPushButton("Create Product")
        self.updateButton = QPushButton("Update Product")
        self.deleteButton = QPushButton("Delete Product")

        self.layout.addWidget(self.getAllButton)
        self.layout.addWidget(self.getButton)
        self.layout.addWidget(self.createButton)
        self.layout.addWidget(self.updateButton)
        self.layout.addWidget(self.deleteButton)

        # Table to display products
        self.productTable = QTableWidget()
        self.productTable.setColumnCount(3)
        self.productTable.setHorizontalHeaderLabels(["ID", "Name", "Description", "Price"])
        self.productTable.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

        self.layout.addWidget(self.productTable)

        # Connect buttons to functions
        self.getAllButton.clicked.connect(self.get_all_products)
        self.getButton.clicked.connect(self.get_product)
        self.createButton.clicked.connect(self.create_product)
        self.updateButton.clicked.connect(self.update_product)
        self.deleteButton.clicked.connect(self.delete_product)

        self.setLayout(self.layout)

    def get_all_products(self):
        # try:
        response = requests.get(f"{API_BASE_URL}/products/", headers=HEADERS)
        response.raise_for_status()
        products = response.json()
        self.show_products_in_table(products)
        # except requests.exceptions.RequestException as e:
        #    QMessageBox.critical(self, "Error", f"Failed to fetch products: {e}")

    def get_product(self):
        product_id = self.productIdInput.text()
        if not product_id:
            QMessageBox.warning(self, "Warning", "Please enter a Product ID.")
            return

        try:
            response = requests.get(f"{API_BASE_URL}/products?id={product_id}", headers=HEADERS)
            response.raise_for_status()
            product = response.json()
            self.productNameInput.setText(product.get("name", ""))
            self.descriptionInput.setText(product.get("description", ""))
            self.productPriceInput.setText(str(product.get("price", "")))
            self.show_products_in_table([product])
        except requests.exceptions.RequestException as e:
            QMessageBox.critical(self, "Error", f"Failed to fetch product: {e}")

    def create_product(self):
        name = self.productNameInput.text()
        description = self.descriptionInput.text()
        price = self.productPriceInput.text()

        if not name or not price:
            QMessageBox.warning(self, "Warning", "Please enter product name and price.")
            return

        try:
            data = {"name": name, "description": description, "price": float(price)}
            response = requests.post(f"{API_BASE_URL}/products", json=data, headers=HEADERS)
            response.raise_for_status()
            if response.status_code == 200:
                QMessageBox.information(self, "Success", response.json().get("message", "Product created"))
                self.get_all_products()  # Refresh after update
            else:
                QMessageBox.warning(self, "Warning", "Failed to add new  product.")
            self.get_all_products()
        except requests.exceptions.RequestException as e:
            QMessageBox.critical(self, "Error", f"Failed to create product: {e}")


def update_product(self):
    product_id = self.productIdInput.text()
    name = self.productNameInput.text()
    description = self.descriptionInput.text()
    price = self.productPriceInput.text()

    if not product_id or not name or not price:
        QMessageBox.warning(self, "Warning", "Please enter Product ID, name, and price.")
        return

    try:
        data = {"name": name, "description": description, "price": float(price)}
        response = requests.put(f"{API_BASE_URL}/products?id={product_id}", json=data, headers=HEADERS)
        response.raise_for_status()
        if response.status_code == 200:
            QMessageBox.information(self, "Success", response.json().get("message", "Product updated"))
            self.get_all_products()  # Refresh after update
        else:
            QMessageBox.warning(self, "Warning", "Failed to update product.")
    except requests.exceptions.RequestException as e:
        QMessageBox.critical(self, "Error", f"Failed to update product: {e}")


def delete_product(self):
    product_id = self.productIdInput.text()
    if not product_id:
        QMessageBox.warning(self, "Warning", "Please enter a Product ID.")
        return

    try:
        response = requests.delete(f"{API_BASE_URL}/products?id={product_id}", headers=HEADERS)
        response.raise_for_status()
        QMessageBox.information(self, "Success", response.json().get("message", "Product deleted"))
        self.get_all_products()
    except requests.exceptions.RequestException as e:
        QMessageBox.critical(self, "Error", f"Failed to delete product: {e}")


def show_products_in_table(self, products):
    self.productTable.setRowCount(len(products))
    for row, product in enumerate(products):
        self.productTable.setItem(row, 0, QTableWidgetItem(str(product.get("id", ""))))
        self.productTable.setItem(row, 1, QTableWidgetItem(product.get("name", "")))
        self.productTable.setItem(row, 2, QTableWidgetItem(product.get("description", "")))
        self.productTable.setItem(row, 3, QTableWidgetItem(str(product.get("price", ""))))


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = ApiClientApp()
    window.show()
    sys.exit(app.exec_())

Key Points

1. Adding Headers

headers = {'Cache-Control': 'no-cache'}

The Cache-Control: no-cache header is important in REST API requests when working with frequently updated data, like our product data. It ensures that each request retrieves the latest data from the server rather than using potentially outdated cached responses.

2. Error Handling and Input Validation

Input Validation: We check if the name and price fields are populated before sending a request. This avoids sending incomplete data and improves user experience.
Error Handling: Wrapping the network request in a try-except block allows us to catch exceptions if the server is unreachable or if there’s an unexpected error.

3. Why Use `Cache-Control: no-cache`?

In scenarios where data consistency is critical

—such as product listings that might change frequently—it’s essential to ensure we aren’t accidentally viewing stale data. Cache-Control: no-cache instructs the client to validate data with the server always, ensuring that any changes on the server are immediately reflected in the client application.

Next Steps

Now that we’ve created the Python client, you can further expand it by:

Adding new API endpoints for handling categories or additional product attributes.
Implementing a refresh button to update the list of products without restarting the application.

You can also experiment with the downloadable POSTMAN collection from the previous articles, which provides a hands-on way to test API interactions.

Building a REST API Client in C# with Windows Form

2024-11-10T18:30:00.012+08:00

In this tutorial, we'll build a simple C# Windows Forms application that connects to a REST API. Our goal is to interact with the products API endpoints we created earlier, using HTTP requests to view, add, update, and delete product records. This tutorial is beginner-friendly and demonstrates how to use HttpClient in C# to communicate with RESTful services. Before diving into this tutorial, it's essential to complete our previous tutorial on creating a REST API using native PHP as a server-side foundation. In that guide, we built a simple REST API to manage products and categories, covering basic API endpoints like creating, updating, deleting, and retrieving product records.

Prerequisites

A basic understanding of C# and Windows Forms.
Visual Studio installed on your machine.
The REST API from the previous tutorial (running locally or on a server).

Project Setup

1. Create a new Windows Forms App in Visual Studio. Open Visual Studio, select Create a new project, and choose Windows Forms App (.NET Framework).

2. Set up UI elements. Design the form with input fields for ID, Name, Description, and Price, as well as buttons for CRUD operations (Get, Create, Update, Delete). Here’s a sample layout:

TextBox for ID
TextBox for Name
TextBox for Description
TextBox for Price
Buttons labeled Get, Create, Update, and Delete
ListBox or DataGridView to display product data

3. In your project, create a Product class to hold the product data. This class will be used to serialize and deserialize JSON.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
}

4. Create a ApiResponse Class to represent the JSON response structure. This class will be used on message handling of some responses.

public class ApiResponse
{
    public string Message { get; set; }
}

Adding Code for API Calls

1. Add necessary using statements at the top of your code:

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Windows.Forms;
using Newtonsoft.Json;
using System.Collections.Generic;

Note: You’ll need to install Newtonsoft.Json from NuGet to handle JSON serialization and deserialization.

2. Initialize HttpClient. We’ll set up HttpClient as a static client to make HTTP requests to the API.

private static readonly HttpClient client = new HttpClient();

3. Define the API URL (change localhost to your API’s address if it’s running on a server).

private readonly string apiUrl = "http://localhost/api/products";
//private readonly string apiUrl = "https://bcssti.com/api-sample/products/";

Implementing CRUD Operations

1. Get Products (GET)

This method fetches the list of all products from the API and displays them in a ListView or DataGridView.

private async void GetProducts()
{
    try
    {
        var response = await client.GetAsync(apiUrl);
        response.EnsureSuccessStatusCode();
        var responseBody = await response.Content.ReadAsStringAsync();
        var products = JsonConvert.DeserializeObject<List<Product>>(responseBody);

        // Display the products in a ListView or DataGridView
        productListBox.DataSource = products;
        productListBox.DisplayMember = "Name"; // Display name or other relevant info
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

2. Get Product by ID (GET)

This method retrieves a single product based on its ID.

private async void GetProductById(int id)
{
    try
    {
        var response = await client.GetAsync($"{apiUrl}?id={id}");
        response.EnsureSuccessStatusCode();
        var responseBody = await response.Content.ReadAsStringAsync();
        var product = JsonConvert.DeserializeObject<Product>(responseBody);

        // Populate fields with product data
        txtName.Text = product.Name;
        txtDescription.Text = product.Description;
        txtPrice.Text = product.Price.ToString();
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

3. Create Product (POST)

This method sends a new product to the API.

private async void CreateProduct()
{
    dynamic product = new 
    {
        name = txtName.Text,
        description = txtDescription.Text,
        price = decimal.Parse(txtPrice.Text)
    };

    var json = JsonConvert.SerializeObject(product);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    try
    {
        var response = await client.PostAsync(apiUrl, content);
        response.EnsureSuccessStatusCode();

        var responseBody = await response.Content.ReadAsStringAsync();
        var apiResponse = JsonConvert.DeserializeObject<ApiResponse>(responseBody);

        // Display the message from the API response
        MessageBox.Show(apiResponse.Message ?? "Product created successfully");
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

4. Update Product (PUT)

This method updates an existing product.

private async void UpdateProduct(int id)
{
    dynamic product = new 
    {
        name = txtName.Text,
        description = txtDescription.Text,
        price = decimal.Parse(txtPrice.Text)
    };

    var json = JsonConvert.SerializeObject(product);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    try
    {
        var response = await client.PutAsync($"{apiUrl}?id={id}", content);
        response.EnsureSuccessStatusCode();

        var responseBody = await response.Content.ReadAsStringAsync();
        var apiResponse = JsonConvert.DeserializeObject<ApiResponse>(responseBody);

        // Display the message from the API response
        MessageBox.Show(apiResponse.Message ?? "Product updated successfully");
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

5. Delete Product (DELETE)

This method deletes a product by ID.

private async void DeleteProduct(int id)
{
    try
    {
        var response = await client.DeleteAsync($"{apiUrl}?id={id}");
        response.EnsureSuccessStatusCode();

        var responseBody = await response.Content.ReadAsStringAsync();
        var apiResponse = JsonConvert.DeserializeObject<ApiResponse>(responseBody);

        // Display the message from the API response
        MessageBox.Show(apiResponse.Message ?? "Product deleted successfully");
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

Testing the Application

Run the Windows Forms App in Visual Studio.
Use the Get button to list all products or retrieve a specific product by ID.
Use the Create, Update, and Delete buttons to interact with the API.

This setup provides a basic client interface for the products API. You can expand this application to manage other objects or add additional features like input validation and error handling.

Final Thoughts

Creating a client for your API in C# Windows Forms is a fantastic way to learn about HTTP communication and RESTful APIs. By using HttpClient and JSON serialization with Newtonsoft.Json, you can quickly set up a functional application to interact with any RESTful service.

This example demonstrates only the basics, but you can extend the client with additional features:

Pagination and Filtering: If your API supports it, implement controls for navigating through pages of data.
Advanced Error Handling: Customize error messages for various HTTP status codes.
UI Improvements: Use DataGridView for more complex data display and editing.

Experiment with these concepts to build a full-featured client for your REST API.

Calling OS Button Functions in C#: Log Off, Shut Down, and Restart

2024-11-09T20:14:00.019+08:00

When working on applications that require direct interaction with the operating system, such as shutting down, logging off, or restarting the system, you can leverage the ExitWindowsEx function from the Windows API. This blog post will demonstrate how to use this functionality in C# with a simple implementation.

The ExitWindowsEx function allows you to log off, shut down, or restart the system. This function is part of the user32.dll library, which can be accessed in C# using the DllImport attribute from the System.Runtime.InteropServices namespace.

Prerequisites

Before implementing the solution, make sure you include the following namespaces:

using System.Runtime.InteropServices;
using System.Diagnostics;

The Code Implementation

Here’s a simple example of how you can define and use the ExitWindowsEx function:

Step 1: Import the Windows API Function

Add the following declaration in your C# class to access the ExitWindowsEx function:

[DllImport("user32.dll")]
public static extern int ExitWindowsEx(int operationFlag, int operationReason);

Step 2: Call OS Button Functions

You can call this function with different parameters depending on the action you want to perform:

1. Log Off the System

ExitWindowsEx(0, 0);

2. Shut Down the System

ExitWindowsEx(1, 0);

3. Restart the System

ExitWindowsEx(2, 0);

Full Code Example

Below is the full implementation:

using System;
using System.Runtime.InteropServices;

class Program
{
    // Importing the Windows API function
    [DllImport("user32.dll")]
    public static extern int ExitWindowsEx(int operationFlag, int operationReason);

    static void Main(string[] args)
    {
        Console.WriteLine("Choose an option:");
        Console.WriteLine("1. Log Off");
        Console.WriteLine("2. Shut Down");
        Console.WriteLine("3. Restart");

        string choice = Console.ReadLine();

        switch (choice)
        {
            case "1":
                // Log off the system
                ExitWindowsEx(0, 0);
                break;
            case "2":
                // Shut down the system
                ExitWindowsEx(1, 0);
                break;
            case "3":
                // Restart the system
                ExitWindowsEx(2, 0);
                break;
            default:
                Console.WriteLine("Invalid choice!");
                break;
        }
    }
}

How It Works

operationFlag: Specifies the operation to perform.

0: Log off.
1: Shut down.
2: Restart.

operationReason: Specifies the reason for the operation. Usually set to 0 for no specific reason.

The ExitWindowsEx function interacts directly with the operating system, making it a powerful yet risky tool. Always ensure proper permissions are in place when deploying such functionality.

Things to Note

1. Administrator Privileges: To shut down or restart the system, your application must have administrator privileges. Without them, the function call will fail.
2. Usage in Applications: Use this functionality sparingly and with caution, as it directly impacts the user’s system.
3. Platform-Specific Code: Since ExitWindowsEx is a Windows API function, this code is specific to Windows systems and won't work on other operating systems.

Building a Simple REST API in Native PHP

2024-11-09T19:58:00.007+08:00

Creating a REST API in PHP is straightforward, even without frameworks like Laravel or Symfony. In this tutorial, we’ll go over the basics of setting up a simple REST API using only native PHP. This is perfect for beginners and small projects that don’t require a complex framework.

What is a REST API?

REST (Representational State Transfer) APIs allow applications to communicate over HTTP by sending requests to access or manipulate data. A RESTful API typically includes HTTP methods like GET, POST, PUT, and DELETE, which correspond to CRUD (Create, Read, Update, Delete) operations.

Prerequisites

PHP installed on your system.
A basic understanding of PHP and HTTP methods.
A simple database (we’ll use MySQL in this example).

Project Structure

For this example, our project will have the following structure:

project-folder/
├── api/
│   ├── config.php
│   ├── database.php
│   ├── categories.php
│   └── products.php
├── products/
│   └── index.php
├── categories/
│   └── index.php
└── index.php

Note
For simplicity, this tutorial focuses on a single entity, products. However, you can apply similar logic to create additional APIs for other entities, such as categories, orders, or customers. Once you're comfortable with these basic steps, try expanding this API by adding endpoints for related data or new functionality.

Step 1: Setting Up the Database

Create a MySQL database and a table for the example. This example uses a products table with some sample fields.

SQL to create the products table:

CREATE DATABASE test_api;

USE test_api;

CREATE TABLE products (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    description TEXT,
    price DECIMAL(10, 2) NOT NULL
);

Step 2: Database Configuration (`config.php`)

In the api folder, create a config.php file to store the database connection details.

<?php
// api/config.php

define('DB_HOST', 'localhost');
define('DB_NAME', 'test_api');
define('DB_USER', 'root');
define('DB_PASS', '');
?>

Step 3: Database Connection Class (`database.php`)

Create a database.php file in the api folder to handle the database connection.

<?php
// api/database.php

class Database {
    private $host = DB_HOST;
    private $db_name = DB_NAME;
    private $username = DB_USER;
    private $password = DB_PASS;
    public $conn;

    public function getConnection() {
        $this->conn = null;
        try {
            $this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name, $this->username, $this->password);
            $this->conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        } catch (PDOException $exception) {
            echo "Connection error: " . $exception->getMessage();
        }
        return $this->conn;
    }
}
?>

Step 4: Creating the API Endpoints (`products.php`)

This file will handle the main API logic. It will listen for different HTTP methods and respond accordingly.

<?php
// api/products.php
include_once 'config.php';
include_once 'database.php';

header("Content-Type: application/json; charset=UTF-8");

$database = new Database();
$db = $database->getConnection();

$requestMethod = $_SERVER["REQUEST_METHOD"];
$request = explode("/", trim($_SERVER["REQUEST_URI"], "/"));

$resource = $request[1] ?? null;

if ($resource !== 'products') {
    echo json_encode(["message" => "Resource not found."]);
    exit();
}

switch ($requestMethod) {
    case 'GET':
        if (isset($_GET['id']) && is_numeric($_GET['id'])) {
            getProduct($_GET['id']);
        } else {
            getProducts();
        }
        break;
    case 'POST':
        createProduct();
        break;
    case 'PUT':
        if (isset($_GET['id']) && is_numeric($_GET['id'])) {
            updateProduct($_GET['id']);
        } else {
            echo json_encode(["message" => "Provide id to updates"]);
        }
        break;
    case 'DELETE':
        if (isset($_GET['id']) && is_numeric($_GET['id'])) {
            deleteProduct($_GET['id']);
        } else {
            echo json_encode(["message" => "Provide id to updates"]);
        }
        break;
    default:
        echo json_encode(["message" => "Method not allowed"]);
        break;
}

function getProducts() {
    global $db;
    $query = "SELECT * FROM products";
    $stmt = $db->prepare($query);
    $stmt->execute();

    $products = $stmt->fetchAll(PDO::FETCH_ASSOC);
    echo json_encode($products);
}

function getProduct($id) {
    global $db;
    $query = "SELECT * FROM products WHERE id = ?";
    $stmt = $db->prepare($query);
    $stmt->execute([$id]);

    $product = $stmt->fetch(PDO::FETCH_ASSOC);
    if ($product) {
        echo json_encode($product);
    } else {
        echo json_encode(["message" => "Product not found"]);
    }
}

function createProduct() {
    global $db;
    $data = json_decode(file_get_contents("php://input"), true);
    $query = "INSERT INTO products (name, description, price) VALUES (?, ?, ?)";
    $stmt = $db->prepare($query);

    if ($stmt->execute([$data['name'], $data['description'], $data['price']])) {
        echo json_encode(["message" => "Product created"]);
    } else {
        echo json_encode(["message" => "Failed to create product"]);
    }
}

function updateProduct($id) {
    global $db;
    $data = json_decode(file_get_contents("php://input"), true);
    $query = "UPDATE products SET name = ?, description = ?, price = ? WHERE id = ?";
    $stmt = $db->prepare($query);

    if ($stmt->execute([$data['name'], $data['description'], $data['price'], $id])) {
        echo json_encode(["message" => "Product updated"]);
    } else {
        echo json_encode(["message" => "Failed to update product"]);
    }
}

function deleteProduct($id) {
    global $db;
    $query = "DELETE FROM products WHERE id = ?";
    $stmt = $db->prepare($query);

    if ($stmt->execute([$id])) {
        echo json_encode(["message" => "Product deleted"]);
    } else {
        echo json_encode(["message" => "Failed to delete product"]);
    }
}
?>

Step 5: Routing Requests to `products.php`

In the products folder, create an index.php file to handle incoming requests and redirect them to products.php inside api folder.

<?php
// index.php

require '../api/products.php';

Step 6: Testing the API

With the API set up, you can test it using a tool like Postman or cURL.

Example Requests

GET All Products: GET https://domain-name.com/project-folder/products/
GET Product by ID: GET https://domain-name.com/project-folder/products?id=1
POST Create Product: POST https://domain-name.com/project-folder/products/ with JSON body:

{
  "name": "New Product",
  "description": "This is a test product",
  "price": 9.99
}

PUT Update Product: PUT https://domain-name.com/project-folder/products?id=1 with JSON body

{
  "name": "Updated Product",
  "description": "This is an updated description",
  "price": 19.99
}

DELETE Product: DELETE https://domain-name.com/project-folder/products?id=1

Download the Postman Collection

To make testing even easier, you can download a Postman collection pre-configured with all the API endpoints used in this tutorial. Simply import the collection into Postman and start sending requests.

Download Postman Collection for Products API

To import the collection you can check this link on How to Import data into Postman.

Conclusion

In this article, we built a simple REST API using native PHP, which handles CRUD operations for a products table in MySQL. This approach is ideal for small applications or for developers who want to learn the fundamentals of REST APIs in PHP. With this setup, you can expand the API by adding authentication, validation, and additional resources.

Creating a REST API using native PHP is a great way to understand the basics of web development and data handling. Once you have mastered this, you can enhance your API with other features, such as:

Authentication and Authorization
Error Handling and Validation
Pagination and Sorting

Experiment with different objects to build a full-fledged backend API for a web or mobile application.

Creating Reports with DevExpress XtraReport from a MySQL Database

2024-11-09T17:29:00.005+08:00

When working with applications that need to display structured data in a report format, DevExpress XtraReport is a powerful tool. In this tutorial, we’ll walk through creating a simple report from a MySQL database using XtraReport in C#.

Prerequisites

To follow along with this tutorial, you’ll need:

DevExpress: Installed in your Visual Studio project (includes XtraReport).
MySQL Database: A database with sample data (for example, a products table with columns like ProductID, ProductName, and Price).
MySQL.Data Connector: The MySQL ADO.NET connector to connect C# to the MySQL database.

Step 1: Set Up the MySQL Database Connection

First, set up a connection to your MySQL database.

1. Install the MySQL.Data NuGet package in Visual Studio.

Install-Package MySql.Data

2. Add your connection details (server, database name, user, and password) in your code.

Here’s an example of how to set up the connection in C#:

using MySql.Data.MySqlClient;
using System.Data;

string connectionString = "Server=localhost;Database=your_database;User ID=root;Password=your_password;";
MySqlConnection connection = new MySqlConnection(connectionString);

Step 2: Retrieve Data from MySQL

Once the connection is set up, query the database to get data for the report.

public DataTable GetProductData()
{
    string query = "SELECT ProductID, ProductName, Price FROM products";
    DataTable dataTable = new DataTable();

    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
        MySqlCommand command = new MySqlCommand(query, connection);
        connection.Open();
        MySqlDataAdapter adapter = new MySqlDataAdapter(command);
        adapter.Fill(dataTable);
    }

    return dataTable;
}

Step 3: Create an XtraReport

Now, create a report in Visual Studio using DevExpress's XtraReport Designer.

1. Add a new XtraReport to your project:

Right-click on your project in Solution Explorer.
Select Add > New Item.
Choose DevExpress Report and name it ProductReport.

2. Bind the Data:

Open ProductReport.cs in the XtraReport Designer.
Go to Data Source and bind the data from GetProductData().

3. Design the Report:

Drag a Detail Band onto the design surface.
Add text labels or fields for each column (e.g., ProductID, ProductName, Price).
Drag data fields from the data source onto the Detail Band to display them in the report.

Here’s an example of the ProductReport code:

using DevExpress.XtraReports.UI;
using System.Data;

public partial class ProductReport : XtraReport
{
    public ProductReport(DataTable dataTable)
    {
        InitializeComponent();
        this.DataSource = dataTable;
        this.DataMember = dataTable.TableName;

        // Bind fields to report labels or cells
        xrLabelProductID.DataBindings.Add("Text", null, "ProductID");
        xrLabelProductName.DataBindings.Add("Text", null, "ProductName");
        xrLabelPrice.DataBindings.Add("Text", null, "Price");
    }
}

Step 4: Display the Report

Now, let’s display the report in your application.

In your form, use the following code to generate the report from the data retrieved from MySQL:

using DevExpress.XtraReports.UI;

// Inside a form or a method
DataTable productData = GetProductData();
ProductReport report = new ProductReport(productData);

// Show the report in the XtraReport viewer
ReportPrintTool printTool = new ReportPrintTool(report);
printTool.ShowPreview();

Running the Application

Now, run your application. When you execute the code, the ProductReport will fetch data from the MySQL database and display it in a report format using DevExpress XtraReport.

Summary

In this article, we demonstrated how to create a simple report from MySQL data using DevExpress XtraReport. We:

Set up a MySQL connection.
Queried data from the products table.
Designed the report using XtraReport Designer.
Displayed the report using the ReportPrintTool.

Using XtraReport with MySQL enables you to generate flexible and visually appealing reports in your applications quickly. With more advanced customization, you can make your reports even more powerful by adding parameters, grouping, and styling options.

Troubleshooting "index.lock" Error in SourceTree

2024-11-09T14:35:00.004+08:00

If you work with Git and use SourceTree, you may occasionally run into an error that prevents you from committing changes. This issue often appears with a message similar to:

"fatal: Unable to create 'path-to-repo/.git/index.lock': File exists. Another git process seems to be running in this repository..."

This article will explain why this happens and provide solutions to resolve it.

What Causes the `index.lock` Error?

The index.lock file is used by Git to prevent multiple processes from making changes to the same repository simultaneously. This lock file is created when a Git command starts and should be removed automatically when the command completes. However, if a Git process is interrupted (e.g., due to a crash or forced closure), the lock file may be left behind, blocking further operations until it is removed.

How to Resolve the `index.lock` Error in SourceTree

Solution 1: Manually Delete the `index.lock` File

The most straightforward way to resolve this issue is to delete the index.lock file manually. Here’s how:

1. Locate Your Repository Folder: Find the folder where your repository is located. In the example from your screenshot, it’s under C:/www/poject-name/.git/.

2. Navigate to the .git Directory: Open the .git folder inside your repository. This is where Git stores all internal configuration and metadata for the repo.

3. Delete the index.lock File: Look for a file named index.lock and delete it. Ensure you only delete this lock file, as other files are essential to your repository.

4. Retry Your Git Operation: Return to SourceTree and try committing again. The error should be resolved.

Note: Make sure no other Git processes are running before deleting index.lock, as this could cause conflicts.

Solution 2: Restart SourceTree and Check for Background Git Processes

If deleting the index.lock file doesn’t solve the issue, restart SourceTree and check if there are any Git processes running in the background:

1. Close SourceTree: Ensure that SourceTree is completely closed.

2. Check for Git Processes:

On Windows, open the Task Manager (Ctrl + Shift + Esc), look for any processes named git.exe, and end them.
On Mac/Linux, use the terminal command ps aux | grep git to find and terminate any running Git processes.

3. Reopen SourceTree: After ensuring no background Git processes are running, reopen SourceTree and try committing again.

Solution 3: Use the Command Line to Complete or Cancel Any Incomplete Operations

Sometimes, Git operations may hang or not complete correctly, especially if SourceTree crashed during a commit or merge. In such cases, running the following command from the command line can help:

1. Open Command Prompt (Windows) or Terminal (Mac/Linux).

2. Navigate to Your Repository:

cd path-to-your-repo

3. Finish or Cancel the Operation: Run git status to check the state of the repository. If there’s an incomplete operation, Git will inform you and may prompt you to complete or abort it.
4. Clear the Lock: If no operation needs completion, you can safely remove the lock file manually using the command:

rm -f .git/index.lock

After this, retry the commit in SourceTree.

How to Avoid the `index.lock` Error in the Future

Here are a few tips to help you avoid encountering this issue:

Allow Git Processes to Complete: Avoid interrupting Git commands once they start, as this can create partial changes and leave lock files.
Close SourceTree Properly: Avoid force-quitting SourceTree. Let it close all Git operations correctly before exiting.
Avoid Running Multiple Git Tools Simultaneously: If you’re working with multiple Git tools (e.g., SourceTree, command-line Git), avoid running commands on the same repository at the same time.

Summary

The index.lock error in SourceTree is a common issue that occurs when a Git process is interrupted or doesn’t complete as expected. By following these solutions, you should be able to resolve the error quickly and continue working without issues.

Solution 1: Delete the index.lock file manually.
Solution 2: Restart SourceTree and check for background Git processes.
Solution 3: Use the command line to finish or cancel incomplete Git operations.

By understanding how Git lock files work and following these troubleshooting steps, you can avoid future disruptions and work smoothly with SourceTree and Git.

How to Update Columns of One Table with Data from Another Table in MySQL

2024-11-07T11:23:00.002+08:00

In MySQL, there are times when we need to update one table with data that resides in another table. This can be particularly useful for synchronizing information, applying calculated values from a related table, or updating records based on specific criteria. This tutorial walks through different approaches to updating columns in one table with values from another table in MySQL.

Scenario: Understanding the Use Case

Suppose we have two tables in a database:

employees: Contains the details of each employee, such as employee_id, name, and department_id.
departments: Stores information about departments, including department_id and department_name.

Let’s say we want to update the employees table to include the department_name from the departments table based on the department_id. This approach is common in situations where you need to sync data between related tables or populate fields for reporting purposes.

Example Table Structures

employees

employee_id	name	department_id	department_name
1	Alice	2	NULL
2	Bob	1	NULL
3	Carol	3	NULL

departments

department_id	department_name
1	HR
2	IT
3	Marketing

In this example, we want to update the department_name column in the employees table to match the corresponding name in the departments table based on department_id.

Basic Syntax: UPDATE with JOIN

In MySQL, you can use an UPDATE JOIN statement to update values in one table with data from another. This approach is efficient and straightforward for joining and updating related tables.

Basic Syntax for UPDATE JOIN

UPDATE table1
JOIN table2 ON table1.common_column = table2.common_column
SET table1.column_to_update = table2.column_with_value
WHERE <conditions>;

Step-by-Step Solution

Identify the Common Key: Make sure both tables share a common column (department_id in this case) to match records.
Use UPDATE JOIN: Use UPDATE JOIN to set the desired column in the target table.
Set the Condition (Optional): Add conditions to limit the records being updated, if necessary.

Implementing the Query

In our scenario, we want to update the employees table with the department_name from the departments table:

UPDATE employees
JOIN departments ON employees.department_id = departments.department_id
SET employees.department_name = departments.department_name;

Explanation

UPDATE employees: Specifies the target table to be updated.
JOIN departments: Joins the employees table to the departments table on the department_id column.
SET employees.department_name: Sets the department_name column in the employees table to the corresponding value in the departments table.

Adding Conditions to the Update

Sometimes, you might want to add conditions to limit which rows get updated. For example, if we only want to update employees who don’t have a department_name assigned yet, we can add a WHERE clause.

UPDATE employees
JOIN departments ON employees.department_id = departments.department_id
SET employees.department_name = departments.department_name
WHERE employees.department_name IS NULL;

This will only update rows where the department_name is currently NULL, leaving existing names unchanged.

Example Execution and Results

Running the above queries will update the employees table as follows:

Before Update:

employee_id	name	department_id	department_name
1	Alice	2	NULL
2	Bob	1	NULL
3	Carol	3	NULL

After Update:

employee_id	name	department_id	department_name
1	Alice	2	IT
2	Bob	1	HR
3	Carol	3	Marketing

Now, the department_name column in employees has been populated with the values from the departments table based on each employee's department_id.

Additional Considerations

Indexing: Ensure that the columns used in the JOIN condition are indexed, especially in large tables, to improve performance.
Backup: Always back up data before running mass UPDATE queries, especially if the changes are complex or involve many rows.
Testing: Try testing queries in smaller datasets or use a SELECT statement with the JOIN first to ensure the data matches the expected result before committing to an update.

Conclusion

Updating one table with data from another table in MySQL can be achieved easily using UPDATE JOIN. This technique helps synchronize data between related tables and can be customized with conditions to refine the update scope. Understanding how to leverage UPDATE JOIN with conditions will enhance your ability to manage and update data across relational tables effectively.

Troubleshooting "Personal Access Client Not Found" Error on API Login Requests

2024-11-04T19:55:00.010+08:00

When building or testing API authentication in Postman, you may encounter an error message stating:

"Personal access client not found. Please create one."

This can be frustrating, especially if you’re unsure how to troubleshoot. This article will guide you through the steps to resolve this error by setting up a personal access client for Laravel Passport authentication.

Error Details

When sending a POST request to the login API endpoint, you might receive the following error response:

{
	"success": false,
	"data": [],
	"message": "Request failed.",
	"errors": "Personal access client not found. Please create one.",
	"tokenResponseCode": false
}

Typical Causes of the Error

This error is a common issue in Laravel applications that use Passport for API authentication. It indicates that there isn’t a valid personal access client configured, which is necessary for handling password grant tokens.

Request Configuration and Endpoint

Let’s assume you’re using the following details in Postman:

Request Parameter:

{
	"username": "{{USERNAME}}",
	"password": "{{PASSWORD}}",
	"app_id": "{{APP_ID}}"
}

Endpoint URL:

{{STAGING_HOST}}/api/cdis/v1/login

If the personal access client is missing, Laravel cannot generate the required access token, resulting in the error.

Solution

To resolve this issue, we need to create a personal access client using the Laravel Artisan command.

Step 1: Open the Command Line Interface (CLI) on the Server

If you’re working on a local environment, open your terminal. For a production server, access the CLI via SSH.

Step 2: Run the Laravel Passport Install Command

Run the following command to create a new personal access client and password grant client:

php artisan passport:install

This command will output the client details required for token generation, similar to the following:

Personal access client created successfully. 
Client ID: 1 
Client secret: hEGVjR9RtB6xHxDJ4wq8K2XQuL8nzA 

Password grant client created successfully. 
Client ID: 2 
Client secret: 4xW4PFqqKjWFudjaJGidHJY2XZcQWy

Take note of the generated Client ID and Client Secret values, as they are essential for configuring your application and API requests.

Step 3: Clear Cache and Config

To ensure Laravel picks up the new configuration, clear any cached configurations by running the following commands:

php artisan config:cache
php artisan config:clear

Step 4: Test the API Endpoint

Return to Postman and try the login request again. If everything is set up correctly, you should receive a successful response with an access token instead of the original error.

Additional Troubleshooting

If you still encounter issues, consider the following:

Ensure Passport is Properly Set Up: Confirm that you’ve set up Passport by running the necessary migration (php artisan migrate) to create the required tables.
Database Check: Verify that the oauth_clients table includes the newly created clients. If not, rerun the Passport install command.

Conclusion

The "Personal access client not found" error can often catch developers off guard, especially when setting up Laravel Passport for the first time. Following these steps should help you configure the necessary client and get your authentication system up and running.

By properly setting up a personal access client with Laravel Passport, you can ensure smooth, secure authentication flows for your API.

How to Retrieve Machine Chassis Information in C#

2024-11-04T17:48:00.007+08:00

When developing Windows applications, you may sometimes need to know what type of chassis (like desktop, laptop, or server) your application is running on. This information can be particularly useful when configuring hardware-specific settings or optimizing application performance for different device types. In this blog post, we’ll explore how to retrieve machine chassis information in C# using Windows Management Instrumentation (WMI).

Let’s walk through a code snippet that identifies the chassis type of the machine your application is running on.

Understanding Chassis Types

Chassis types refer to the physical configuration of a computer, such as a desktop, laptop, or rack-mounted server. In C#, we can define an enumeration (enum) to represent these types. Here’s a list of common chassis types:

public enum ChassisTypes
{
    Other = 1,
    Unknown,
    Desktop,
    LowProfileDesktop,
    PizzaBox,
    MiniTower,
    Tower,
    Portable,
    Laptop,
    Notebook,
    Handheld,
    DockingStation,
    AllInOne,
    SubNotebook,
    SpaceSaving,
    LunchBox,
    MainSystemChassis,
    ExpansionChassis,
    SubChassis,
    BusExpansionChassis,
    PeripheralChassis,
    StorageChassis,
    RackMountChassis,
    SealedCasePC
}

Each chassis type is assigned an integer value. This allows us to map numerical identifiers retrieved from the system to specific chassis descriptions.

Retrieving the Current Chassis Type

To access the chassis type, we use WMI (Windows Management Instrumentation) to query the Win32_SystemEnclosure class, which contains information about the computer chassis. The ChassisTypes property in this class returns an array of integers representing possible chassis types.

Here’s the full code to retrieve the current chassis type:

using System;
using System.Management;

public static class ChassisInfo
{
    public static ChassisTypes GetCurrentChassisType()
    {
        ManagementClass systemEnclosures = new ManagementClass("Win32_SystemEnclosure");
        
        foreach (ManagementObject obj in systemEnclosures.GetInstances())
        {
            foreach (int i in (UInt16[])(obj["ChassisTypes"]))
            {
                if (i > 0 && i < 25)
                {
                    return (ChassisTypes)i;
                }
            }
        }
        
        return ChassisTypes.Unknown;
    }
}

Let’s break down the code step-by-step:

ManagementClass Initialization: We start by initializing a ManagementClass object for the Win32_SystemEnclosure WMI class.
Query Instances: We retrieve all instances of Win32_SystemEnclosure. Although there’s typically only one instance per machine, this approach handles multiple instances if necessary.
Retrieve Chassis Types: For each instance, we read the ChassisTypes property, which is an array of integers (of type UInt16[]). Each integer corresponds to a chassis type.
Map Integer to Enum: We check if the integer is within the range of defined values in our ChassisTypes enum (1 to 24). If valid, we cast the integer to a ChassisTypes value and return it.
Default to Unknown: If no valid chassis type is found, we return ChassisTypes.Unknown.

Example Usage

To get the chassis type and display it in your application, call GetCurrentChassisType() like so:

public class Program
{
    public static void Main()
    {
        ChassisTypes chassisType = ChassisInfo.GetCurrentChassisType();
        Console.WriteLine("Current Chassis Type: " + chassisType);
    }
}

When run, this code will output the chassis type of the machine, for example:

Current Chassis Type: Laptop

Why Use WMI for Chassis Information?

WMI provides a standardized way to retrieve system information across Windows devices. By leveraging WMI, we can query detailed hardware information without requiring direct access to device-specific APIs, making the code more portable and easier to maintain.

Use Cases for Chassis Information

Retrieving chassis type information can be useful in various scenarios, such as:

Tailoring Software for Different Devices: You might have specific configurations for desktops, laptops, and servers to optimize performance and usability.
Security and Compliance: Knowing the device type can help enforce different security policies, such as stricter protocols on portable devices like laptops.
Device-Specific UI Adjustments: On handheld or laptop devices, your application may need a more compact UI, while desktops and servers can afford more screen space.

Conclusion

With the code shown above, you can easily retrieve the chassis type of a machine in C#. This can be a powerful tool in applications that need to adapt to different hardware types. By using WMI and enums in C#, your application can gain insights into the device it’s running on, leading to more adaptable and efficient solutions.

You can get the complete on Github

How to Create a Mock Controller with User Data in Laravel

2024-11-04T16:25:00.008+08:00

Working on a Laravel project and need sample user data for testing purposes? Setting up a mock controller with some realistic user data can be a great approach, especially if you're prototyping or want to focus on front-end features without setting up a database. In this article, we’ll walk through creating a UsersController in Laravel that provides mock user data and implements CRUD operations for demonstration and testing.

1. Setting Up the Controller

To begin, create a new controller in Laravel named UsersController. This will serve as our mock API endpoint for managing user data. We’ll store our user data in an array, simulating a database table.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;

class UsersController extends Controller
{
    public $users;

    function __construct() {
        // Sample users data
        $this->users = [
            [
                'id' => 1,
                'name' => 'Emma Smith',
                'email' => 'smith@kpmg.com',
                'position' => 'Art Director',
                'role' => 'Administrator',
                'last_login' => 'Yesterday',
                'two_steps' => false,
                'joined_day' => "10 Nov 2022, 9:23 pm",
                'online' => false
            ],
            // Additional sample users here
        ];
    }
}

This constructor method initializes an array of user data. Each user has attributes like id, name, email, role, and last_login. You can customize these attributes to fit your needs.

2. Fetching Users List with Pagination and Filters

Our next step is to create a method to fetch all users, including pagination and filtering functionality. This helps us simulate a real database where we can retrieve, sort, and filter data.

public function getUsers(Request $request)
{
    $usersCollection = collect($this->users);
    $page = $request->input('page', 1);
    $perPage = $request->input("items_per_page", 10);

    // Search and filter logic here
    // Paginate users
    $paginatedUsers = $this->paginate($usersCollection, $perPage, $page);

    return response(["data" => $paginatedUsers->toArray()], 200);
}

This method retrieves users as a collection and paginates the results. We also implement a helper function paginate() to manually paginate the data.

3. Adding a User

Adding a new user in this mock setup requires validating the input and appending it to our users array. Here’s how:

public function addUser(Request $request)
{
    $data = json_decode($request->getContent(), true);

    $validator = Validator::make($data, [
        'name' => 'required|string|max:255',
        'email' => 'required|string|email|max:255',
        'role' => 'required|string|max:255',
    ]);

    if ($validator->fails()) {
        return response(["errors" => $validator->errors()], 422);
    }

    $data["id"] = count($this->users) + 1;
    $this->users[] = $data;

    return response(["data" => $data], 201);
}

This function adds a new user only if the data is valid, simulating the behavior of a real database-backed POST request.

4. Updating User Data

Updating a user’s information is similar to adding a new user, but here we first locate the user by ID, then update the existing array entry:

public function updateUser(Request $request, $id)
{
    $data = json_decode($request->getContent(), true);

    $validator = Validator::make($data, [
        'name' => 'required|string|max:255',
        'email' => 'required|string|email|max:255',
        'role' => 'required|string|max:255',
    ]);

    if ($validator->fails()) {
        return response(["errors" => $validator->errors()], 422);
    }

    $user = collect($this->users)->firstWhere('id', $id);

    if (!$user) {
        return response(["message" => "User not found"], 404);
    }

    $user = array_merge($user, $data);
    return response(["data" => $user], 200);
}

5. Deleting a User

Deleting a user is as straightforward as removing the user by ID from the array. Here’s a simple deleteUser function:

<?php
public function deleteUser($id)
{
    $key = array_search($id, array_column($this->users, 'id'));

    if ($key === false) {
        return response(["message" => "User not found"], 404);
    }

    unset($this->users[$key]);
    return response(null, 204);
}

6. Creating the Paginate Function

Since we’re working with an array instead of a database, we need a custom paginator. Here’s a function to handle manual pagination:

<?php
public function paginate($items, $perPage = 10, $page = null)
{
    $page = $page ?: (Paginator::resolveCurrentPage() ?: 1);
    $items = $items instanceof Collection ? $items : Collection::make($items);
    return new LengthAwarePaginator($items->forPage($page, $perPage)->values(), $items->count(), $perPage, $page);
}

The paginate function lets us handle pagination just like we would with Eloquent collections.

Wrapping Up

With this setup, you now have a fully functional mock user controller in Laravel! This mock controller can be extended with additional endpoints or adapted to handle more complex mock data requirements. Whether you’re building a front-end prototype or testing Laravel API responses, this approach can save you time and simplify your development process.

You can get the complete code here on Github

Flutter Live Location Tracking using Supabase

2024-09-12T22:01:00.012+08:00

To implement live location tracking with polylines from the start coordinates to destination coordinates, and to use Supabase for real-time updates, you can follow this approach.

Steps:

Set Up Supabase:
- Sign up on Supabase.
- Create a project and a table to store location updates (with columns like latitude, longitude, timestamp, user_id).
- Use Supabase’s real-time features to broadcast location changes.

Add Supabase and Necessary Packages: In your pubspec.yaml, include the following dependencies:

dependencies:
  flutter:
    sdk: flutter
  google_maps_flutter: ^2.1.7
  location: ^4.3.0
  supabase_flutter: ^1.0.0
  polyline_do: ^1.0.0

Supabase Setup: Add Supabase's API Key and URL in your project.
Flutter Code Implementation with Polylines and Real-time Updates:

import 'package:flutter/material.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import 'package:location/location.dart';
import 'package:supabase_flutter/supabase_flutter.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Supabase.initialize(
    url: 'your-supabase-url',
    anonKey: 'your-supabase-anon-key',
  );
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Live Location with Supabase',
      home: LiveLocationWithPolyline(),
      debugShowCheckedModeBanner: false,
    );
  }
}

class LiveLocationWithPolyline extends StatefulWidget {
  @override
  _LiveLocationWithPolylineState createState() =>
      _LiveLocationWithPolylineState();
}

class _LiveLocationWithPolylineState extends State<LiveLocationWithPolyline> {
  late GoogleMapController _mapController;
  Location _location = Location();
  LatLng _initialPosition = LatLng(37.42796133580664, -122.085749655962);
  LatLng? _destination;
  Set<Polyline> _polylines = {};
  List<LatLng> polylineCoordinates = [];
  bool _liveUpdate = true;
  final SupabaseClient supabase = Supabase.instance.client;

  void _onMapCreated(GoogleMapController controller) {
    _mapController = controller;
    _location.onLocationChanged.listen((LocationData locationData) async {
      if (_liveUpdate) {
        LatLng currentPosition =
            LatLng(locationData.latitude!, locationData.longitude!);

        _mapController.animateCamera(
          CameraUpdate.newCameraPosition(
            CameraPosition(target: currentPosition, zoom: 16.0),
          ),
        );

        if (_destination != null) {
          polylineCoordinates.add(currentPosition);
          setState(() {
            _polylines.add(
              Polyline(
                polylineId: PolylineId('route'),
                points: polylineCoordinates,
                color: Colors.blue,
                width: 5,
              ),
            );
          });
        }

        // Update current location to Supabase
        await supabase.from('locations').insert({
          'latitude': locationData.latitude!,
          'longitude': locationData.longitude!,
          'timestamp': DateTime.now().toIso8601String(),
          'user_id': 'user_1', // Add your user identification logic
        });
      }
    });
  }

  void _trackSupabaseUpdates() {
    supabase
        .from('locations')
        .on(SupabaseEventTypes.insert, (payload) {
          final data = payload.newRecord;
          LatLng newLocation =
              LatLng(data['latitude'], data['longitude']);

          if (_destination == null) {
            _destination = newLocation;
            setState(() {
              polylineCoordinates.add(_initialPosition);
              polylineCoordinates.add(newLocation);
            });
          }
        })
        .subscribe();
  }

  @override
  void initState() {
    super.initState();
    _location.requestPermission().then((granted) {
      if (granted == PermissionStatus.granted) {
        _trackSupabaseUpdates();
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Live Location with Supabase"),
        actions: [
          Switch(
            value: _liveUpdate,
            onChanged: (value) {
              setState(() {
                _liveUpdate = value;
              });
            },
            activeColor: Colors.green,
            inactiveThumbColor: Colors.red,
          ),
        ],
      ),
      body: _initialPosition == null
          ? Center(child: CircularProgressIndicator())
          : GoogleMap(
              initialCameraPosition: CameraPosition(
                target: _initialPosition,
                zoom: 16.0,
              ),
              onMapCreated: _onMapCreated,
              myLocationEnabled: true,
              myLocationButtonEnabled: true,
              mapType: MapType.normal,
              polylines: _polylines,
            ),
    );
  }
}

Key Features:

Live Location Tracking with Polylines: The code listens for real-time location updates using the Location package and draws polylines on the map to show the path from the start to the destination.
Supabase Realtime: Every time the location changes, it is stored in the Supabase database. Other clients can receive real-time updates via Supabase’s real-time subscriptions. In this case, the new destination is tracked from Supabase updates.
Polyline Display: As the user's location updates, a polyline (blue line) is drawn on the map showing the route to the destination.

Notes:

Ensure that you have set up your Supabase instance with a locations table containing columns like latitude, longitude, timestamp, and user_id.
You can refine how real-time updates are handled to manage multiple users and optimize location updates for performance.

tarsier-marianz

🔥 How to Create a Beautiful Custom Arrow Button in Flutter with Ripple Effect

🛠️ How to Implement

1. Create an Arrow Clipper

2. Build the Custom Button Widget

3. Example Usage:

Creating a Laravel Command to Clear Log Files

Steps:

Why Preserve .gitignore?

How to Create and Publish a Dart/Flutter Package to pub.dev

Step 1: Create a New Package

Using the Dart Command Line

Using the Flutter Command Line (if it's a Flutter package)

Folder Structure

Step 2: Implement Your Package Code

Edit the Main Library File

Step 3: Add Metadata in pubspec.yaml

Step 4: Add Documentation

Create a README.md File

Add a CHANGELOG File

Add a LICENSE File

Step 5: Test Your Package

Step 6: Prepare for Publishing

Verify Your Package

Format Your Code (Optional)

Step 7: Publish Your Package

Authenticate with pub.dev

Publish Your Package

Step 8: Verify on pub.dev

🧰 pubspec_checker package for Flutter

Features

Getting started

Usage

Examples

Additional information

Contributing

License

How to Create a Custom Dropdown Color Menu in Flutter

Step 1: Setting Up the Flutter Project

Step 2: Building the Color Dropdown Menu

Code: Custom Dropdown Color Menu

Step 3: Running the Application

OutputHow It Works

Code Enhancement

Updated Code: Custom Dropdown with Color Names

Output of the enhanced code

Explanation of Enhancements

How It Works

How to Set Up Virtual Serial COM Ports Using com0com

Step 1: Download com0com

Step 2: Install com0com

Step 3: Verify com0com Installation

Step 4: Configure Virtual COM Ports

Using the GUI Configuration Tool

Step 5: Test the Virtual COM Ports

Interfacing Arduino L293D Driver with NPN Bipolar Transistor to Save Output Pins for Motor Direction Control

Understanding the L293D Motor Driver

The Problem

The Solution: Using an NPN Transistor

How It Works

Logic Table

Circuit Diagram

Code Implementation

Working Explanation

Advantages of This Approach

Joystick-605620: 3-Axis Joystick with Push Button

Objective

Features

Components Used

Use Cases

Disclaimer

Github Repository

Troubleshooting Laravel Passport Migration Errors: "Table Already Exists"

The Problem

Solution

1. Identify Existing Tables

2. Remove Existing Tables

3. Clear Migration Cache (Optional)

4. Re-run Laravel Migrations

Why Does This Happen?

Why Preserve `.gitignore`?

Step 3: Add Metadata in `pubspec.yaml`

Create a `README.md` File

Add a `LICENSE` File

Output

How It Works

**3. Clear Migration Cache (Optional)**

1. Delete the Existing `package-lock.json` File

1. Setting Up HTTP Requests with `HttpURLConnection`

3. Why Use `Cache-Control: no-cache`?