DEV Community: Süleyman Özgür Özarpacı

Using AI to Help My Girlfriend's Lectures

Süleyman Özgür Özarpacı — Tue, 30 Dec 2025 11:50:38 +0000

My girlfriend has lots of things to study, so I wanted to try to help her. She has lots of notes, lecture videos, and all sorts of medical materials. I decided to choose one topic to test if I could gather all the information into one place and then create a basic quiz about it.

I started with a video first. The video was 1 hour and 20 minutes long. So watching and creating notes from it would be too hard. Plus, I don't understand most of the medical words. So I had to transcribe it. But the other obstacle was that the video had Turkish, English, and Latin languages at the same time. So I couldn't directly transcribe from English or Turkish or even Latin.

I researched transcription apps and I found they were too pricey. I don't have that much money for unknown output. So I tried from simple tools to more complicated ones. I used WhisperDesk. It understands but translates to English. Also even the large model wasn't enough to get nice results. Sometimes it got stuck in the same place for no reason. Then I found Speech2Text. I don't want to use a CLI, so there was a GUI at the first place - thanks to open source! I tried it and it did really well at the beginning, but it had the same stuck issue. Maybe the duration of the video was too long? I separated the MP3 file where the teacher was giving a break. Now I had 3 parts. I transcribed them and voilà, it worked.

Now we had to make it pretty. I removed the timestamps, extra spaces, and made every line a sentence. Then I used Cursor to make it pretty and as a markdown file with topics separated. Also, I asked if some abbreviations or words could be wrong, so fix them based on the context.

Wow, it's been a long journey. I spent 2-3 hours by now, but I did well. Now I checked the notes based on the video part by part and then merged them. Now we had nice context and information. After this, we could use AI to create anything based on the content. I asked Cursor to create a sample quiz page with: text input, true/false or multiple choice questions. Create minimum 30 questions based on the notes. When user gives the answer, immediately show the answer with explanation. Use Bootstrap and don't use custom colors, etc. Use plain Bootstrap. Only create an index.html file.

You can't believe it, but Cursor again did a very well job. We tried it and we loved it. Now my girlfriend has all the notes and EKG content, has sample quiz questions with explanations, and she can practice as she wants.

This project shows how modern AI tools can make content processing and application development faster and easier. By combining transcription technology, AI content improvement, and automated code generation, I created a complete study solution in just a few hours. The approach demonstrates practical ways to use AI in education technology, making complex content easier to understand and more interactive for students.

How My Medicine Student Girlfriend Completed Simple Development Tasks for Me

Süleyman Özgür Özarpacı — Sun, 21 Dec 2025 13:35:47 +0000

I have a girlfriend who is studying medicine. She has no background in programming, but she is highly adaptive and curious. One day, I decided to give her some of my development tasks and see what would happen.

The development environment was already running, so I simply handed my computer to her. I explained at a high level how to interact with the Cursor's UI, how to prompt the AI, and how to review results. After that, I went off to do my chores.

Some time later, she came back and showed me the result. It was surprisingly acceptable. I reviewed the code and found no major issues. She had even generated an AI-based commit message, which was reasonable, and then committed her first piece of code.

Encouraged by this, I gave her another task. This one was more complex: it involved APIs, SSR, and Tailwind—in short, a frontend task. It was clearly too large to be solved with a single prompt, so I gave her one key piece of advice:

Don’t give the whole task at once. Break it into smaller steps.
Start with a static frontend, then integrate the API, and finally make it SSR-compatible.

With that guidance, I went back to my chores.

When I returned, she had completed the task. Once again, she generated an AI commit message and committed the changes herself.

She continued this process and completed all five of my tasks in about 1 to 1.5 hours. At the end, she looked at me and said,

“Is this your job? You just explain what you need, and after some time it’s done? That’s too easy.”

At that point, I had nothing to say.

She enjoyed “vibe coding,” I finished my chores, and everyone was happy.

Observations and Reflections

I’m not entirely sure where this fits from an ethical perspective, but I genuinely enjoyed the experience. What made it interesting was not productivity, but observation.

I was able to see how a non-programmer approaches software development using modern AI-assisted tools. I saw the struggles: understanding abstract concepts, translating vague requirements into concrete steps, and deciding whether the output was actually correct. I also saw the enjoyment: fast feedback, visible progress, and a sense of accomplishment despite having no traditional programming background.

Watching this process made one thing very clear: the real challenge was never typing code. It was breaking the problem down, sequencing tasks, and knowing when something was “done enough” versus technically correct.

A More Realistic Take on AI in Development

I don’t believe that modern software development is shifting from writing code to directing systems. That framing feels misleading.

What I do believe is this: AI is becoming extremely good at helping us solve well-scoped, basic problems, often with one or two prompts. For larger or more complex tasks, it still requires clear, step-by-step instructions. And those instructions do not come from the AI; they come from the engineer.

In highly abstracted or well-separated projects, you are still the engineer of the system. You define the architecture, the constraints, the trade-offs, and the long-term direction. AI does not replace that role. It acts as a companion.

A very capable one.

AI helps by:

Implementing routine or repetitive code quickly
Improving existing code through refactoring
Writing tests and suggesting edge cases
Surfacing relevant documentation and context
Bootstrapping features or even entire applications

But none of this removes the need for engineering judgment. AI does not understand business context, long-term maintainability, or non-obvious constraints unless those are explicitly provided, and even then, it cannot own those decisions.

In practice, AI behaves more like an always-available junior-to-mid-level collaborator. It can move fast, but it still needs guidance, boundaries, and review.

Conclusion

This small experiment reinforced something important for me: AI is not replacing software engineers, but it is reshaping how we work.

The value of an engineer is increasingly found in problem decomposition, system design, and critical evaluation, not in typing speed or memorizing syntax. When those skills are present, AI becomes a powerful multiplier. When they are not, AI output quickly degrades into noise.

Seeing a medical student, someone completely outside the software world, successfully complete development tasks was both impressive and grounding. It showed how accessible tooling has become but also highlighted how much invisible expertise still sits behind “simple” instructions.

And yes, it also means I might outsource more development tasks at home, at least when chores are involved.

How I Use AI Coding Assistants (and How You Can Use Them Better)

Süleyman Özgür Özarpacı — Thu, 04 Dec 2025 13:01:40 +0000

AI coding assistants have become a hot topic. Some developers say they are terrible and slow them down, while others say AI helps them work faster and reduce mental load. So why is the experience so different? What are some people doing wrong, and what are others doing right?

This post explains how AI coding assistants actually work, how to give them the right context, and how you can get much better results by improving your prompts and your workflow.

1. AI Assistants Work With “Empty Boxes”

AI models are not magical coders who understand your project automatically. They only know what you tell them. Think of each model as an empty box (its context window). If you don’t fill that box with the correct and relevant information, the assistant will guess and usually guess wrong.

Before asking an AI assistant to perform a task, it needs to understand:

Your framework and coding standards
Your project structure
The purpose of the feature
Any useful packages or tools
The current state of your code

Advanced editors like Cursor help here. They inject a high-quality system prompt and index your entire project. Because of that, Cursor can automatically pull relevant files when needed. Your local or basic AI tools probably can’t, because they never receive that system prompt or indexed context.

But even with advanced tools, you must still give specific instructions.

2. “Fix X Feature” Is Not a Prompt

One of the biggest mistakes developers make is giving vague instructions.
For example:

“Improve the UserController.”

This is too broad. The assistant doesn’t know what “improve” means. Instead, be specific about the problem and the expected solution:

“UserController.php is too large and difficult to maintain. Please refactor it into smaller classes and services based on SOLID principles. Move business logic into services or repositories and keep the controller clean.”

This works because:

You define the problem
You describe the desired direction
You limit the scope

Give the assistant the same clarity you would give a new teammate.

3. Give Only the Context That the Task Needs

More context is not always better. If the agent is working on the payment module, you do not need to include the whole report module, notification module, or unrelated controllers. Too much context leads to:

Confused output
Higher token costs
Slower responses

Keep context focused. Let the assistant “build bridges” only when the information is truly related.

4. Good Prompts Are Detailed and Transparent

If you already know what the error is, or why something is broken, tell the assistant directly. Provide:

The problem
The error message
Log output or stack trace
The response you expect
Any constraints or rules

You don’t lose control when you do this, you gain better results. Don’t be secretive with information you already know.

5. Choose the Right Model for the Job

You wouldn’t hire a physicist to fix your plumbing. Model selection works the same way.

Use small models when:

Tasks are small
Context needs are minimal
You want fast and cheap responses

Use larger models when:

Tasks are complex
You need bigger context windows
You need deep reasoning

You don’t always need the biggest or smartest model. You need the right one.

6. Create Reusable Context Files

To improve your workflow, create a folder like .ai-context/ and add small, organized Markdown files:

Project structure
Development rules
Packages and how they are used
Environment differences
Module explanations
High-level architecture
System flow diagrams
Example usages

Keep the files small, focused, and non-repetitive. Link between files when needed so the assistant can navigate them.

For example, if you use a library or package:

Create a small .md file that explains the library with simple examples.
Add it to .ai-context/packages/.
In your main architecture file, just reference it.

This creates a knowledge base the AI can rely on, just like onboarding documentation for new developers.

7. Use AI to Improve Your Prompts

If you don’t feel confident in English (B2 or below), ask another AI model to rewrite your prompt:

“Please improve this prompt for coding agents.”

This is a simple trick but makes a big difference in code quality.

Conclusion

AI coding assistants are powerful tools, but only when we use them correctly. They are not mind readers, and they cannot magically understand your entire project without the right context, structure, and guidance. When you give them focused information, clear problems, and well-prepared prompts, they become real partners that can speed up your work and reduce your mental load.

Remember: be specific, stay organized, give only the context that matters, and choose the right model for the task. Treat the AI like a new teammate who needs directions, not a machine that knows everything. If you build a good system around how you give tasks, you will get reliable, consistent, and high-quality results.

AI will not replace developers but developers who know how to work with AI will definitely have an advantage.

How to Fix "The MAC is invalid." Exception in Spatie Permission

Süleyman Özgür Özarpacı — Mon, 05 May 2025 18:13:59 +0000

In many of my Laravel projects, I use Spatie's Permission package alongside encrypted settings to keep sensitive data safe from breaches. However, this can create an issue when you copy production data to a local or staging environment. Since encryption keys differ between environments, attempting to decrypt the settings can result in the following exception:

The MAC is invalid.

This error typically occurs because Laravel is trying to decrypt data that was encrypted with a different application key (APP_KEY). To solve this, I wrote a custom Artisan command that resets all encrypted setting values to an empty string.

The Solution: Reset All Encrypted Setting Values

Here’s the command:

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\File;
use Spatie\LaravelSettings\SettingsRepositories\SettingsRepository;
use Spatie\LaravelSettings\Support\Crypto;

class EmptyAllEncryptedSettingKeysCommand extends Command
{
    protected $signature = 'app:empty-all-encrypted-setting-keys';
    protected $description = 'Reset all encrypted setting values to an empty string.';

    public function handle(): int
    {
        $settingsFolder = app_path('Settings');
        $files = File::allFiles($settingsFolder);
        $settingsRepository = app(SettingsRepository::class);

        foreach ($files as $file) {
            $relativePath = $file->getRelativePathname();

            $settingsClass = str_replace(
                ['/', '.php'],
                ['\\', ''],
                'App\\Settings\\' . $relativePath
            );

            if (class_exists($settingsClass) && method_exists($settingsClass, 'encrypted')) {
                foreach ($settingsClass::encrypted() as $key) {
                    $settingsRepository->updatePropertiesPayload(
                        $settingsClass::group(),
                        [$key => Crypto::encrypt('')]
                    );
                }
            }
        }

        $this->info('All encrypted setting values have been reset.');
        return Command::SUCCESS;
    }
}

What Does This Command Do?

It scans all classes under App\Settings\*.
For each class, it checks if it has an encrypted() method (used to declare encrypted properties).
It loops through those encrypted keys and replaces their values with an empty encrypted string using Spatie\LaravelSettings.

Why This Helps

When you clone your production database to another environment (e.g., staging or local), any encrypted values cannot be decrypted unless the encryption key (APP_KEY) matches. Instead of trying to sync keys across environments (which is insecure), it's often safer and easier to just reset encrypted values.

Running this command prevents "The MAC is invalid." exception and allows you to work with the rest of the settings normally.

How to Trigger Another Action in FilamentPHP

Süleyman Özgür Özarpacı — Sat, 23 Nov 2024 16:21:52 +0000

If you have an Action in FilamentPHP and want to trigger another action sequentially within it, you can use the Action Chaining feature.

Example Scenario

Suppose you have an action called DuplicateAction, and after it completes, you want the EditAction to open automatically. Below is an example implementation of both actions.

EditAction Example

Here’s how you can define the EditAction:

Action::make('edit')
    ->fillForm(function (array $arguments) {
        $id = $arguments['id'];
        $item = Item::find($id);

        return $item ? $item->toArray() : [];
    })
    ->form(fn () => [
        // Your form fields go here
    ])
    ->action(function (array $arguments, $data) {
        $id = $arguments['id'];

        $item = Item::find($id);
        if (!$item) {
            return;
        }

        $item->update($data);
    });

DuplicateAction Example

Here’s how you can define the DuplicateAction and trigger the EditAction after duplicating:

return Action::make('duplicate')
    ->requiresConfirmation()
    ->modalDescription('Are you sure you want to duplicate this item?')
    ->action(function (array $arguments) {
        $id = $arguments['id'];
        $isEdit = isset($arguments['edit']);

        $item = Item::find($id);
        if (!$item) {
            return;
        }

        $newItem = $item->replicate();
        $newItem->name = $newItem->name . ' (copy)';
        $newItem->afterNode($item)->save();

        if ($isEdit) {
            $this->replaceMountedAction('edit', [
                'id' => $newItem->id,
            ]);
        }
    })
    ->extraModalFooterActions(fn (Action $action): array => [
        $action->makeModalSubmitAction('duplicateAndEdit', arguments: ['edit' => true])
            ->label('Duplicate and Edit'),
    ]);

Explanation

EditAction: Opens a form pre-filled with the data of the selected item. When the user submits the form, it updates the item in the database.
DuplicateAction:
- Duplicates the selected item and appends " (copy)" to its name.
- Offers an additional button in the modal footer, labeled "Duplicate and Edit," which duplicates the item and directly triggers the EditAction with the duplicated item's data.

By using this method, you can seamlessly open actions sequentially, enhancing the user experience.

Simplifying Asset Updates in FilamentPHP Packages

Süleyman Özgür Özarpacı — Sat, 23 Nov 2024 14:35:04 +0000

For the past week, I’ve been developing a FilamentPHP package, and this process has taught me quite a bit. However, I’d like to share something with you that I couldn’t find in the documentation.

When you run npm run dev during the development of your package, the files are built into the /resources/dist directory at the root of your package. FilamentPHP then moves these files to the public directory of your Laravel project when you execute the php artisan filament:assets command. Therefore, every time you make a change in your FilamentPHP package, you need to run this command in the Laravel project you’re testing on to reflect the updates in the public directory.

But what if I told you there’s an easier way? The magic word here is symlink ✨.

Checking File Names

First, open the service provider file of your package. For my package, this is the FilamentMenuBuilderServiceProvider.php file.

In your getAssets method, ensure that the exported file name matches the actual file name inside your package. This is crucial because when we create the symlink, the Filament panel will look for the file using the exported name. Since I’m only using a CSS file, my code looks like this:

protected function getAssets(): array
{
    return [
        // WRONG!
        Css::make('filament-menu-builder-styles', __DIR__ . '/../resources/dist/filament-menu-builder.css'),

        // CORRECT!
        Css::make('filament-menu-builder', __DIR__ . '/../resources/dist/filament-menu-builder.css'),
    ];
}

For more information, please read the documention.

Creating a Symlink

The process of creating a symlink varies depending on your operating system. Since I’m using Windows, I utilize Link Shell Extension for this purpose.

I symlink the /resources/dist directory to /public/css/{vendor_name}/{package_name} in my Laravel project. For my project, this would be /public/css/biostate/filament-builder. From now on, any changes in the dist folder of my package will automatically reflect in the public directory of my Laravel project.

Conclusion

By leveraging symlinks, you can significantly streamline your development process for FilamentPHP packages. This eliminates the repetitive task of running php artisan filament:assets after every change, allowing you to focus more on building and less on manual updates.

Throwing Success or Failure Notifications Manually in FilamentPHP Actions

Süleyman Özgür Özarpacı — Sat, 09 Nov 2024 23:47:47 +0000

When developing with Filament, there are times when you might need to display success or failure notifications based on the results of an action. Using success and failure methods allows you to manage these notifications manually, giving more control over how and when messages are shown to users.

Step 1: Create the Base `Action` Code

Let's start by creating a base Action that will display a modal with specific input fields. This example sets up an action called "Regenerate Media Conversions," with a form where users can specify options for media conversion.

Action::make('Regenerate Media Conversions')
    ->requiresConfirmation()
    ->modalWidth('2xl')
    ->form([
        Select::make('media')
            ->options([
                null => 'All',
                Product::class => 'Only Products',
                Category::class => 'Only Categories',
            ]),
        TextInput::make('ids')
            ->placeholder('1,2,3,4,5'),
        Checkbox::make('only_missing')
            ->default(false),
        Checkbox::make('with_responsive_images')
            ->default(true),
    ])
    ->action(function ($data) {
        /* Perform your specific action here */
    }),

This code creates a modal with a form containing fields for media selection, IDs, and additional options. With these inputs, you can then customize and perform any necessary tasks, such as regenerating media conversions.

Step 2: Set Success and Failure Titles

To make sure notifications appear upon success or failure, set the titles for these messages using the successNotificationTitle and failureNotificationTitle methods. Without these, no notifications will be shown even if the action succeeds or fails.

Action::make('Regenerate Media Conversions')
    ...
    ->successNotificationTitle('Process started. You will be notified.')
    ->failureNotificationTitle('Process failed.'),

Step 3: Modify the `action` Method to Trigger Notifications

Now, let's update the action method to actually throw the success or failure notifications. Here’s how to handle both cases within a try-catch block.

Action::make('Regenerate Media Conversions')
   ...
    ->action(function ($data, Action $action) {
        try {
            /* Perform your specific action */
            $action->success(); // Trigger success notification
        } catch (\Exception $e) {
            $action->failure(); // Trigger failure notification

            return false;
        }
    }),

Step 4: Customizing Success or Failure Messages

If you need to dynamically adjust the success or failure messages based on certain conditions, use the successNotificationTitle and failureNotificationTitle methods within the action function. For instance:

Action::make('Regenerate Media Conversions')
    ->action(function ($data, Action $action) {
        try {
            /* Perform your specific action */
            if ($isQueued) {
                $action->successNotificationTitle('Process queued successfully.');
            } else {
                $action->successNotificationTitle('Process started immediately.');
            }
            $action->success(); // Trigger success notification
        } catch (\Exception $e) {
            $action->failureNotificationTitle('Process failed with error: ' . $e->getMessage());
            $action->failure(); // Trigger failure notification

            return false;
        }
    }),

This approach enables you to display custom messages for both queued and non-queued processes, as well as detailed error information if the action fails.

Conclusion

By manually setting success and failure notifications in Filament actions, you gain control over the feedback displayed to users, allowing for customized messages based on specific conditions or outcomes. This not only enhances user experience but also improves clarity when things go right or wrong.

How to Minify and Cache CSS & JS Files in Laravel

Süleyman Özgür Özarpacı — Mon, 21 Oct 2024 10:00:00 +0000

In modern web development, speed and performance are crucial for delivering a seamless user experience. One of the most effective techniques for optimizing performance is minification. Minification involves removing unnecessary characters from CSS and JavaScript files—such as whitespace, comments, and line breaks—without affecting their functionality. This process reduces file sizes, leading to faster load times, lower bandwidth consumption, and an overall improved user experience, especially for those on slower networks.

While tools like Laravel Mix or Vite are often used to manage and optimize assets, there are scenarios where these tools may not be applicable—such as when working with files provided by users or external sources. In such cases, manual optimization becomes necessary. In this article, we'll demonstrate how to optimize and stream these files directly using PHP, focusing on implementing minification in a Laravel project with the help of the matthiasmullie/minify package.

Step 1: Install the `matthiasmullie/minify` Package

To get started, install the matthiasmullie/minify package via Composer. This package provides a simple API for minifying both CSS and JavaScript files.

composer require matthiasmullie/minify

Step 2: Create a Minification Route

Next, add the following route to your web.php file. This route will handle requests to minify any CSS or JS file and serve the minified content, caching the result for improved performance.

use Illuminate\Support\Facades\Cache;
use MatthiasMullie\Minify\CSS;
use MatthiasMullie\Minify\JS;

Route::get('minify/{any}', function ($any) {
    $path = public_path($any);

    // Cache the checksum of the file
    $checksum = Cache::remember("file_checksum:{$path}", 60 * 24 * 365, function () use ($path) {
        return md5_file($path);
    });

    // Cache the file content based on the checksum
    $content = Cache::remember("file_content:{$checksum}", 60 * 24 * 365, function () use ($path, $any) {
        $extension = pathinfo($any, PATHINFO_EXTENSION);

        switch ($extension) {
            case 'css':
                $minifier = new CSS($path);
                $minifiedContent = $minifier->minify();
                return ['content' => $minifiedContent, 'headers' => ['Content-Type' => 'text/css']];
            case 'js':
                $minifier = new JS($path);
                $minifiedContent = $minifier->minify();
                return ['content' => $minifiedContent, 'headers' => ['Content-Type' => 'application/javascript']];
            default:
                return ['content' => file_get_contents($path), 'headers' => ['Content-Type' => 'text/plain']];
        }
    });

    // Set content and headers
    $response = response($content['content'], 200, $content['headers']);

    // Set Cache-Control, Expires and ETag headers for browser caching
    $cacheDuration = 60 * 24 * 365; // 1 year in minutes
    return $response->header('Cache-Control', "public, max-age=" . ($cacheDuration * 60))
        ->header('Expires', now()->addMinutes($cacheDuration)->toRfc7231String())
        ->header('ETag', $checksum); // ETag for validation
})->where('any', '.*')->name('themes_file');

Step 3: Usage

Once you've followed the steps above, you can start using the minification feature by updating your HTML references. For example, if you have the following CSS and JavaScript references:

<link rel="stylesheet" href="/css/style.css"/>
<script type="text/javascript" src="js/main.js"></script>

You will need to modify them to point to the minified versions as follows:

<link rel="stylesheet" href="/minify/css/style.css"/>
<script type="text/javascript" src="/minify/js/main.js"></script>

After the first request, your CSS and JavaScript files will be minified and cached within your application. Additionally, the user's browser will cache these files, significantly reducing load times on subsequent visits. This caching mechanism ensures both server-side and client-side performance improvements.

Step 4: Key Considerations

This route performs two main tasks: it minifies the requested file (CSS or JS) and caches the result for quicker responses in future requests. The use of ETag and Cache-Control headers ensures that the browser can cache these assets for up to one year, reducing server load and speeding up content delivery.

However, this is just a basic implementation. To improve readability and maintainability, you can further optimize the code using design patterns like the Strategy Pattern or leverage a more robust asset management tool. Laravel Mix or other bundlers like Webpack can also be integrated for more complex use cases.

Conclusion

Minification is a simple yet effective way to boost your website's performance by reducing file sizes and improving load times. With Laravel and the matthiasmullie/minify package, you can quickly implement minification and caching for your CSS and JavaScript files. While this article demonstrates a basic implementation, consider exploring more advanced optimizations and design patterns to ensure your application remains maintainable as it scales.

How to Change Local Storage Path in Laravel

Süleyman Özgür Özarpacı — Wed, 02 Oct 2024 19:00:06 +0000

In Laravel, there may be instances where you need to change your storage path to accommodate specific requirements. For example, in my case, I encountered an issue with insufficient disk space for my projects. To resolve this, I purchased a DigitalOcean Volume to expand my storage capacity. In this article, I will demonstrate two methods to modify your storage path effectively.

Creating the Volume

To begin, log in to your DigitalOcean account and navigate to the Droplets section. Select your droplet, then go to the Volumes tab. From there, create a new volume, specifying the size according to your storage requirements.

Server Configuration

Since I am using Laravel Forge, I need to connect to the server via SSH to verify that the volume has been successfully attached to my droplet. Use the following command:

ssh forge@[YOUR_IP_ADDRESS]
lsblk

Find the disk you added from the list. In our setup, the disk appears as volume_fra1_01, and its mount path is /mnt/volume_fra1_01.

Next, create a storage folder for your application within the new volume:

sudo mkdir /mnt/volume_fra1_01/[app_name]_storage

If you already have an existing storage folder, copy its contents to the newly created folder:

sudo cp -r /var/www/your_laravel_project/storage /mnt/volume_fra1_01/[app_name]_storage

As a precaution, in case anything goes wrong, rename the original storage folder:

mv storage backup_storage

Since the newly created folder resides under the root user, update its permissions to those recommended by Laravel, and change the owner to forge:

sudo chown -R forge:forge /mnt/volume_fra1_01/[app_name]_storage
sudo chmod -R 755 /mnt/volume_fra1_01/[app_name]_storage

Application Configuration

At this stage, you have two options:

Update without modifying the application by creating a symlink.
Change the storage path within the application itself.

Option 1: Using a Symlink (The Most Stable Method)

Navigate to the root directory of your application and create a symlink for the new storage directory:

cd [your_laravel_project_path]
ln -s /mnt/volume_fra1_01/[app_name]_storage/ storage

Option 2: Modifying the Application

To update the storage path within the application, add the following code to the boot method of your AppServiceProvider.php file:

$this->app->useStoragePath(config('app.app_storage_path'));

Then, add this line to your app.php configuration file:

]
    // Your other configurations
    'app_storage_path' => env('APP_STORAGE_PATH', base_path().'/storage'), // Add this line
];

One of the most common mistakes made during this process is directly using the env() method in the application without adding the corresponding value to app.php. If you do this, when you run config:cache, the env() method will always return null, causing your application to malfunction. Therefore, I highly recommend that for every value you add to the .env file, you also define a corresponding entry in a configuration file to ensure proper functionality.

If you've added the above code, you can now dynamically change your application's storage path by adding the APP_STORAGE_PATH value to your .env file. If you don't add this value, the application will default to using the storage folder in your root directory.

APP_STORAGE_PATH="/mnt/volume_fra1_01/[app_name]_storage" # <-- Use this value to change your storage path

Note: Option 2 may cause errors depending on the packages, code structure, or features you use in your application. If you choose this method, I strongly recommend running your tests and manually checking your application afterward.

Conclusion

To finalize, ensure that you clear all cached data by running:

php artisan optimize:clear

By following these steps, you now have the flexibility to update your storage path as needed, allowing your application to leverage any desired disk for file storage. This method provides enhanced adaptability and scalability, ensuring your Laravel application can continue to grow alongside your storage requirements.

Turn Your MySQL to Case Sensitivity on Windows

Süleyman Özgür Özarpacı — Mon, 15 Apr 2024 17:47:32 +0000

When working with MySQL on Windows, you might notice that table names are not case-sensitive by default. This is because the Windows file system is case-insensitive, unlike Linux or macOS, which can lead to unexpected behavior if your development or production environment depends on case-sensitive table names. In my case, I am using Windows 11, and I needed to enable case sensitivity for a project where I need to ensure that User and user are treated as distinct table names. Here’s how I achieved that.

Step 1: Locate Your MySQL Configuration File

The first step in making MySQL case-sensitive is to modify the MySQL configuration file (my.ini). Depending on how MySQL is installed on your machine, the path to this file can vary. In my case, I'm using Laragon, so my configuration file is located here:

C:\laragon\bin\mysql\mysql-8.0.13-winx64\my.ini

You will need to open this file with a text editor like Notepad or an IDE of your choice.

Step 2: Modify the my.ini Configuration

Once you've opened the my.ini file, search for the [mysqld] section. This is where you will add a new configuration line to enable case sensitivity. Insert the following line directly under the [mysqld] header:

lower_case_table_names=0

This setting tells MySQL to preserve the case of table names, making the database case-sensitive. By default, on Windows, the value is 1, which means MySQL converts all table names to lowercase, regardless of how they are defined.

Step 3: Adjusting the Windows File System

Although adding the above configuration enables MySQL to respect case sensitivity, there’s one important thing to note: the Windows file system is inherently case-insensitive. That means even with lower_case_table_names=0, your file system will still treat User and user as the same file or folder, leading to potential issues.

To overcome this limitation, you need to configure the Windows file system to support case-sensitive directories. This requires some additional steps.

Step 4: Enable Case Sensitivity in Windows

You will need to enable case sensitivity for the folder where MySQL stores your database files. This folder is typically located under your MySQL installation's data directory. In my setup, it’s located here:

C:\laragon\data

Before proceeding, I recommend making a backup of all your existing database files and folders in case anything goes wrong. Once that’s done, you can enable case sensitivity for this folder by running the following command in an elevated Command Prompt (run as Administrator):

fsutil.exe file SetCaseSensitiveInfo C:\laragon\data enable

This command tells Windows to enable case sensitivity for the specified directory, which is crucial for MySQL to handle table names in a case-sensitive manner.

Step 5: Restart MySQL

After making the above changes, you should restart the MySQL service for the new configuration to take effect. If everything is set up correctly, MySQL should now treat User and user as two separate tables, just like it would on a case-sensitive file system.

Final Thoughts

Enabling case sensitivity on MySQL in Windows can be tricky due to the underlying nature of the Windows file system, but by following the steps outlined above, you should be able to achieve the desired behavior. Remember that while this works well for development environments, it's always a good idea to match your production environment closely to avoid any surprises when deploying your application.

For more details on this topic, check out the following resources:

Case-Sensitive Table Names in MySQL
How to Make Windows Folders Case-Sensitive
Managing MySQL Lower Case Table Names

Theme Management in Laravel

Süleyman Özgür Özarpacı — Wed, 13 Sep 2023 16:49:37 +0000

At times, you may find the need to manage themes in your Laravel project. For this purpose, the hexadog/laravel-themes-manager package will fulfill your requirements.

How it works?

The algorithm behind this package is elegantly simple yet remarkably powerful. It seamlessly integrates your theme path into Laravel's default View Finder paths, revolutionizing your ability to manage and customize views.

The View Finder carries out its search for views in the following order:

It first looks in the current theme's designated path.
If the current theme has a parent theme, it extends its search to include the parent theme's path.
As a fallback, it checks Laravel's default resources/views folder.

This versatile package also empowers you to override third-party package vendor files and error views with ease. You have the flexibility to create custom views for specific scenarios, such as errors/404.blade.php or vendor/mail/notifications/email.blade.php, tailored to each theme's unique requirements.

For more detailed information on how this works and utilizing views effectively, you can refer to the following resources:

Child Theme Support

The child theme feature enables your theme to inherit properties and functionality from a parent theme. By utilizing this feature, your child theme becomes dependent on the parent theme, allowing for efficient theme customization.

For instance, let's say you've developed a theme named default/example, and you need to introduce modifications like a simplified product listing or different color schemes. In such cases, creating a child theme becomes essential. You can easily create a child theme named default/example-simple and proceed to add specific elements like the components/product-list-item.blade.php view.

With this setup, the theme manager prioritizes the views within your child theme, utilizing them instead of the parent theme's defaults. If the theme manager doesn't find a particular element in your child theme, it gracefully falls back to the parent theme, ensuring a seamless and flexible theme management experience.

Setup

Please follow documentation to setup package.

Creating Theme

The package includes a vendor prefix at the beginning of your theme name, ensuring that theme names remain unique. This vendor name serves as a differentiator, allowing you to create themes like commerce/example and commerce-b2b/example. While the theme names may appear the same, they reside in distinct vendor namespaces, preventing conflicts.

Creating a new theme is an effortless process. Simply execute the following command and provide the necessary inputs:

php artisan theme:make

This command creates these files:

themes
    ├── vendorName
    │   ├── themeName
    │   │   ├── public
    │   │   │   ├── css
    │   │   │   ├── js
    │   │   │   ├── img
    │   │   └── resources
    │   │   │   ├── views
    │   │   │   │   ├── layouts
    │   │   │   │   │   └── app.blade.php
    │   │   │   │   │   └── guest.blade.php
    │   │   └── composer.json
    │   └── ...
    └── ...

Using Themes

You have the flexibility to incorporate themes either within a controller or as part of a middleware. To seamlessly integrate theme logic into your Laravel project, you can refer to the following documentation pages:

These resources provide detailed guidance on implementing themes to enhance the visual and functional aspects of your application.

Conclusion

Embracing theme management in your Laravel project with the hexadog/laravel-themes-manager package opens up exciting possibilities for customization. You can effortlessly create themes, enhance views, and seamlessly apply them in controllers or middleware. Whether you're building a complex e-commerce site or a straightforward blog, this package simplifies the theme integration process, making it a valuable asset for Laravel developers. Start exploring theme management today to take your Laravel projects to the next level of visual and functional excellence.

How to Stop FilamentPHP Actions On Certain Conditions

Süleyman Özgür Özarpacı — Sun, 06 Aug 2023 00:58:30 +0000

In some cases, FilamentPHP processes need to be stopped based on certain conditions. To achieve this, we can use the cancel()method of an action. This article demonstrates how to use cancel() effectively and includes notifications to provide meaningful feedback to users.

You can also use halt() but halt does not close modals.

Example Scenario:
Consider a scenario where we want to prevent force-deleting a user if they have active orders. We will use a ForceDeleteBulkAction and its before callback to perform the necessary checks and notify the user accordingly.

Tables\Actions\ForceDeleteBulkAction::make()
    ->before(
        function ($records, Tables\Actions\ForceDeleteBulkAction $action) {
            // code goes here
        }
    )

Checking for Active Orders and Canceling the Process:
To check for active orders, query the relevant data and cancel the process if any orders are found. We can achieve this as follows:

Tables\Actions\ForceDeleteBulkAction::make()
    ->before(
        function ($records, Tables\Actions\ForceDeleteBulkAction $action) {
+            $ids = $records->pluck('id')->toArray();
+            $exists = Order::whereIn('user_id', $ids)->exists();
+            if ($exists) {
+                $action->cancel();
+            }
        }
    )

Cancel does not show notification about why process canceled. Use Notification documentation.

+use Filament\Notifications\Notification;

Tables\Actions\ForceDeleteBulkAction::make()
    ->before(
        function ($records, Tables\Actions\ForceDeleteBulkAction $action) {
            $ids = $record->orders()->pluck('id')->toArray();
            $exists = Order::whereIn('user_id', $ids)->exists();
            if ($exists) {
+                Notification::make()
+                    ->title('Errors!')
+                    ->body("You can't force delete users because someone has orders.")
+                    ->status('danger')
+                    ->send();
                $action->cancel();
           }
        }
    )

By using the cancel() method in FilamentPHP, we can effectively halt an action based on specific conditions. In the example provided, we prevent force-deleting users with active orders and enhance the user experience by sending a notification explaining the reason for the process cancellation. This approach ensures that users are informed about the constraints and can take appropriate actions accordingly.

DEV Community: Süleyman Özgür Özarpacı

Using AI to Help My Girlfriend's Lectures

How My Medicine Student Girlfriend Completed Simple Development Tasks for Me

Observations and Reflections

A More Realistic Take on AI in Development

Conclusion

How I Use AI Coding Assistants (and How You Can Use Them Better)

1. AI Assistants Work With “Empty Boxes”

2. “Fix X Feature” Is Not a Prompt

3. Give Only the Context That the Task Needs

4. Good Prompts Are Detailed and Transparent

5. Choose the Right Model for the Job

6. Create Reusable Context Files

7. Use AI to Improve Your Prompts

Conclusion

How to Fix "The MAC is invalid." Exception in Spatie Permission

The Solution: Reset All Encrypted Setting Values

What Does This Command Do?

Why This Helps

How to Trigger Another Action in FilamentPHP

Example Scenario

EditAction Example

DuplicateAction Example

Explanation

Simplifying Asset Updates in FilamentPHP Packages

Checking File Names

Creating a Symlink

Conclusion

Throwing Success or Failure Notifications Manually in FilamentPHP Actions

Step 1: Create the Base Action Code

Step 2: Set Success and Failure Titles

Step 3: Modify the action Method to Trigger Notifications

Step 4: Customizing Success or Failure Messages

Conclusion

How to Minify and Cache CSS & JS Files in Laravel

Step 1: Install the matthiasmullie/minify Package

Step 2: Create a Minification Route

Step 3: Usage

Step 4: Key Considerations

Conclusion

How to Change Local Storage Path in Laravel

Creating the Volume

Server Configuration

Application Configuration

Option 1: Using a Symlink (The Most Stable Method)

Option 2: Modifying the Application

Conclusion

Turn Your MySQL to Case Sensitivity on Windows

Step 1: Locate Your MySQL Configuration File

Step 2: Modify the my.ini Configuration

Step 3: Adjusting the Windows File System

Step 4: Enable Case Sensitivity in Windows

Step 5: Restart MySQL

Final Thoughts

Theme Management in Laravel

How it works?

Child Theme Support

Setup

Creating Theme

Using Themes

Conclusion

How to Stop FilamentPHP Actions On Certain Conditions

Step 1: Create the Base `Action` Code

Step 3: Modify the `action` Method to Trigger Notifications

Step 1: Install the `matthiasmullie/minify` Package