Here is how to automatically increment your project’s build number using only 3 lines of code!

1. Go to Targets > MyFunApp and click on the Build Phases tab

2. Click the + button in the top left corner of the Build Phases area, select New Run Script Phase

3. We want this to run after Link Binary with Libraries, so drag Run Script below Link Binary with Libraries

4. Change Shell to /bin/bash and paste the below code in the script area as show in Example 2.

5. That’s it. Now when you Build your project, the build number will auto increment.

How to debug issues

For some of you this process will work out of the box and for some of you this process will not work. So what’s going on?

We can open the Report Navigator. On the left you’ll see your most recent build event. Click on it and scroll down to Run Script and click the More… link.

You can see that there was a Syntax Error for the token CURRENT_PROJECT_VERSION. This is the most common issue you’ll run into.

The process we are using to increment the build number reads your project’s Info.plist. If we open, Info.plist, you will see in the Bundle Version key a value of `$(CURRENT_PROJECT_VERSION)`

If you have ever manually entered a bundle version on the General tab of your Target, then XCode will place `$(CURRENT_PROJECT_VERSION)` in the Info.plist. Replace the entire value to the number you want your Build Number to start at and press Enter. Next time you build, the Build Number will increment.

That’s it. This is just another tool to add to your toolkit. This is Part 1 in this series. In Part 2, I’ll show you how to change other key/values in your project.

Increment Build Numbers in XCode with 3 lines of code! was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

I recently wrote about using scp to copy files, while that is still perfectly valid, scp had a few limitations. So let’s look at rsync for copying files to a remote computer. Depending upon your use case, you can decide which one works for you.

rsync compares the data you are sending and receiving so it doesn’t have to resend data that was already previously sent, saving you extra time and bandwidth.

If you are copying files to remote machine regularly, use the rsync command. Depending on your need, it’s probably a good idea to just use rsyncfor all file moves inter-system.

Syntax: rsync [options] <source> <destination>

An example:

rsync -av /path/to/folder/ remote_computer:/remote/path/to/folder/

The beauty of rsync is that it will synchronize a local directory with a remote directory!

If you run the same command a second time, the contents of the local directory (which have not changed) will not be transferred! This is way more efficient than running scp and copying everything every time the command is run.

The rsync options that I use the most frequently are:

-a : Archive mode (includes default common options like preserving symlinks)
-v : Verbose mode show files as they are being moved
-P : Show progress of the files as they are being transferred. Notice that’s a capital ‘P’.

— delete : Delete files from the destination folder that are not in the local folder. This is useful to keep the remote folders cleaned up and better in sync. If it’s not in the local folder, it’s getting deleted on the remote folder.

An example using options:

rsync -Pav --delete /path/to/folder/ remote_computer:/remote/path/to/folder/

For more options check out the rsync manual page: https://linux.die.net/man/1/rsync

Why you should be using rsync to copy files remotely was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

The build.gradle file is used as a “template” to generate your BuildConfig.java file behind the scenes.

Let’s start with a simple example.

Switch to the Project View (mostly likely you’re in the Android View), of Android Studio.

Right-click your application’s root project folder and select New > File. Name it demo.properties

Open that file and add

MY_CUSTOM_URL=http://www.google.com

Now open the build.gradle file, scroll to the bottom and start by defining the name of our file.

def propFile = new File(‘demo.properties’)

We will be reading in the properties file and line-by-line and adding those properties to the build config section.

You should see the Gradle message letting you know that the Gradle file has changed and needs to be re-synced. Click the Sync Now button.

After syncing, you can test if everything worked by opening one of your Activities or Fragments and adding the line:

Log.v(“MyActivity”, BuildConfig.MY_CUSTOM_URL);

You can also click the BuildConfig class name and press CMD+B(or CTRL+B on Windows) to open that file. You should see your key/values have been added. The BuildConfig.java class and its fields can be accessed by our activities directly.

Now you’re ready to start adding in your own keys and values!

Managing Your Android Project Using Gradle Properties was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

Make your life easier with a Global GitIgnore.

Why?

I got tired of copying and pasting the same set of ignore files for every project I created. Now, I keep all my OS and IDE specific files in a global gitignore and keep project specific files in the project’s gitignore.

What files go in a global gitignore file?

Operating system files should go in a global gitignore. This might include things like your IDEs settings, or temp files, metadata files, icon cache files etc..

Files you want to ignore in your project, should go into the project’s .gitignore.
Things like vendor packages, composer packages, cocoa-pods, Python virtual environments, Gradle files, basically any 3rd-party library. If you use some sort of package management system, then those packages should be in the .gitignore. Provided of course, you keep the definition file in your project that allows you to re-download those libraries.

On MacOS

Open Terminal and run the below command to create a new file. You don’t have to name it .gitignore_global you could name it .gitignore I appended _global so future me will remember what the file is used for.

touch ~/.gitignore_global

Now, let’s configure Git to use the exclude file ~/.gitignore_global for all Git repositories.

git config --global core.excludesfile ~/.gitignore_global

Finally, open your new gitignore_global in Notepad or TextEdit and fill it with your computer/IDE level exclusions.

On Windows

Open Git Bash.

Navigate to the root folder of your user profile usually at C:\Users\{myusername}\and create a .gitignore_global file.

Then run

git config --global core.excludesfile "%USERPROFILE%\.gitignore"

Using Windows PowerShell?

Run:git config --global core.excludesfile "$Env:USERPROFILE\.gitignore"

Verify it

Not every system is setup the same. So you can verify your MacOS, Windows or Windows PowerShell config file is correct by running:

git config --global core.excludesfile

The output should be the full path to your file.

If you see $HOME/.gitignore_global or %USERPROFILE%\.gitignore then something has gone wrong.

On Windows, if you can’t get it to work using the %USERPROFILE% variable, you can just run from the bash prompt

git config — global core.excludesfile ~/.gitignore_global

Then, navigate into that folder and open the .gitconfig file (it’s hidden) and manually edit the excludesfile path to to reflect the location of your .gitignore_global

It might looks something like this:

[core]
excludesfile = C:\Users\adammcelhaney\.gitignore_global

Special Note

Git will not ignore a file that was already tracked before a rule was added to this file to ignore it. If you find you have checked in a file that you need to be un-tracked, you can run:

git rm --cached filename

Need suggestions on what to add to your Global GitIgnore?

Be sure to check Github’s own repo of suggested ignore files: https://github.com/github/gitignore

Create a Global GitIgnore Step-by-Step for MacOS and Windows was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

You don’t have to be logged in with SSH to copy files from your local machine to a remote computer. When you use scp on your local computer, the scp process will log you into the remote server, copy the file, then log you out again all in one go.

Syntax: scp <source> <destination>

To copy a file from your Local computer to a Remote computer:

scp /path/to/file username@remote:/path/to/destination

To copy a file from Remote to Local while logged in to Remote:

scp username@remote:/path/to/file /path/to/destination

If you want to preserve the file’s metadata (modification times, modes, etc..) use the -p option after the scp command.
scp -p <source> <destination>

If you want to copy all the folders recursively

scp -r <source> <destination>

Note: Keep in mind that this won’t preserve symlinks

It’s considered a good practice to use -rp when coping files.

An example:

scp -rp /My/Local/Folder/File.ext root@192.168.1.101:/my/remote/folder/

Some caveats with SCP

• You can’t move files between two remote computers. Either the source or destination must be a file hosted locally relative to the machine you are logged into. However, if you log in to a remote machine with ssh, you can then copy files from that computer to another remote computer from machine you are remotely logged into command-line.
• You can only scp to a folder on a remote computer that you have permission to.
• The order of options is important! Switching from -rp to -pr, won’t copy the folders but only their contents to the target directory.

For more options check the scp man page https://linux.die.net/man/1/scp

Copy Files To A Remote Computer Using The Command Line was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

While this tutorial applies mostly to Laravel, the validation and client side examples can be applied to any project. Your implementation may be a little different than mine, so I have tried to generalize this enough that you should be able to massage this example into any of your own projects.

Create ReCaptcha Account

Start by heading over to www.google.com/recaptcha and add a new site.

Enter the domain name where your form lives and give it an identifying label. It can be anything you want since it’s just for your reference.

If you want to test from your local computer (and not from your site directly), I recommend creating another separate site in the admin console and add localhost and 127.0.0.1 to the list of domains and use those keys for development while using the keys for your domain in production.

Technically, can you just add localhost and 127.0.0.1 to the same list as the one with your domain on it, but that’s not really a good practice.

When you Save, you’ll be taken to a screen that contains your public and private keys. Copy those down making sure you know which one is public and which is private.

In your Laravel project, open your .env file and add two new key/values to the bottom of your .env file. You can name them whatever you like, but I chose the below format. Paste the keys you just copied from the Google ReCaptcha site.

GOOGLE_CAPTCHA_PUBLIC_KEY=6LMt06UdrMt06UhiUAAAAAN3IRTYMd6NOKfdadc
GOOGLE_CAPTCHA_PRIVATE_KEY=4pzo1dJefhkbcIC1qjo1dJeeevxFTer5UHGmrt

Add Composer Package

Update composer.json and add google/recaptcha to the require object and use the most recent version.

Note: If you get the error during installation:

Composer update: The requested PHP extension ext-http missing

Look in your composer.json require object to see if it contains “ext-http”: “*” If so, remove it. PHPStorm and some other IDEs will add key/value to remove any lint and other code warnings.

Once composer has installed the ReCaptcha package, you’re now ready to move on.

Update the Blade File

Note: This section can apply to any project, not just a Laravel project.
Open the blade file that holds the form you want to protect with ReCaptcha.

Find the start of your form tag and add a hidden input field called recaptcha_token. I added mine directly after the @csrf directive.

<input type=’hidden’ name=’recaptcha_token’ id=’recaptcha_token’>

In a moment, we will be creating a Rule class to handle validation. Depending on how you handle errors, you may want to show any ReCaptcha error messages on the form. We can do this by:

{{ — Show the user the recaptcha_token error. — }}
@if($errors->has(‘recaptcha_token’))
    {{$errors->first(‘recaptcha_token’)}}
@endif

Next, we need to link to the Google ReCaptcha Service and pass in the our public env key.

Add the below JavaScript to the scripts section of your Blade, html file or however you handle JavaScript.

Creating the Rule

Run the artisan command to make a new rule.

php artisan make:rule ReCaptchaRule

When that command has finished, open up the new file so we can edit it. It is stored in the app/Rules folder.

Add the statement use ReCaptcha\ReCaptcha; a the top of the class. I also would like to be able to customize the returned error message based upon the response from Google, so I’ll add a private $error_msg property to the top of the ReCaptchaRule class that will be returned in the rule’s message() function.

In the passes() function, let’s check to very that the $value is not empty, if so, set the error message to show that the field is required.

if (empty($value)) {
   $this->error_msg = ':attribute field is required.';
   
   return false;
}

Next, you’ll create a new ReCaptcha object and pass in your private .env key.

$recaptcha = new ReCaptcha(env('GOOGLE_CAPTCHA_PRIVATE_KEY'));

ReCaptcha requires some configuration before it validates the passed token.

Set the hostname to your SERVER_NAME. This should match the domain you listed in the Google ReCaptcha admin console.

Next, you’ll need to set your Score Threshold. This is will be a value between 0 and 1. The threshold really depends on your sites needs. The higher the threshold the more strict ReCaptcha is in trying to determine if a user is a bot or not.

Start with 0.5 and work your way up to fit your needs.

Finally, we will verify the passed token from the form field and the user’s IP address storing the response in a variable.

$resp      = $recaptcha->setExpectedHostname($_SERVER['SERVER_NAME'])
                  ->setScoreThreshold(0.5)
                  ->verify($value, $_SERVER['REMOTE_ADDR']);

Luckily, the ReCaptcha package we installed with composer has some nice functions to use against the response.

If the response is NOT successful, we can set various error messages depending on the response. If the returned score is less than our threshold, we will let the user know they failed the ReCaptcha test.

Otherwise, they have passed the ReCaptcha test so we need to return true to finish out the rule.

if (!$resp->isSuccess()) {
   $this->error_msg = 'ReCaptcha field is required.';
   
   return false;
}

if ($resp->getScore() < 0.5) {
   $this->error_msg = 'Failed to validate captcha.';
   
   return false;
}


return true;

My finished Rule class looks like this:

class ReCaptchaRule implements Rule
{
   
   private $error_msg = '';

   public function __construct()
   {}
   
   public function passes($attribute, $value)
   {
      if (empty($value)) {
         $this->error_msg = ':attribute field is required.';
         
         return false;
      }
      
      $recaptcha = new ReCaptcha(env('GOOGLE_CAPTCHA_PRIVATE_KEY'));
      $resp      =   $recaptcha->setExpectedHostname($_SERVER['SERVER_NAME'])
                        ->setScoreThreshold(0.5)
                        ->verify($value, $_SERVER['REMOTE_ADDR']);
      
      if (!$resp->isSuccess()) {
         $this->error_msg = 'ReCaptcha field is required.';
         
         return false;
      }
      
      if ($resp->getScore() < 0.5) {
         $this->error_msg = 'Failed to validate captcha.';
         
         return false;
      }
      
      
      return true;
      
   }
   
   public function message()
   {
      return $this->error_msg;
   }
}

Update your FormRequest

If you’re submitting a form, chances are you’re using a FormRequest (and you should). In my example my FormRequest class is called ContactUsFormRequest.

In rules() method, where you add all the the fields validation rules, you’ll want to add another rule to the rules array for your new ReCaptcha field you added in your blade file.

‘recaptcha_token’ => [‘required’, new   ReCaptchaRule($this->recaptcha_token)]

The key name ‘recaptcha_token’ is the name of that hidden field we added to the form earlier. I chose to make it required and then pass the form field’s value to the ReCaptcha rule as a parameter.

So my ContactUsFormRequest looks something like this now.

public function rules()
{
 $rules = [‘name’ => [‘required’, ‘min:3’, ‘max:25’,
 ‘email’ => [‘required’, ‘email’],
 ‘message’ => [‘min:10’],
 ‘recaptcha_token’ => [‘required’, new   ReCaptchaRule($this->recaptcha_token)]
 ];
 
 return $rules;
}

Note: I don’t have to add any extra error messages the ContactUsFormRequest’s messages() function, since that is now handled by the Rule class we created.

That’s it.

Now you’re ready to protect your form using ReCaptcha V3!

BONUS ROUND

To remove the “ReCaptcha logo” from your site:

You are allowed to hide the badge as long as you include the ReCaptcha branding visibly on your form.
See https://developers.google.com/recaptcha/docs/faq for more on what you’re allowed to do.

To hide the badge simply add the CSS style

.grecaptcha-badge { visibility: hidden; }

Next include the ReCaptcha branding text, by adding

This site is protected by ReCaptcha and the Google
<a href=”https://policies.google.com/privacy">Privacy Policy</a> and
<a href=”https://policies.google.com/terms">Terms of Service</a> apply.

For example:

Using ReCaptcha V3 and Laravel in 2020 was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

I recently was working with some large JSON objects and needed to output the contents to the console. The JSON was well over 2,000 characters long and wouldn’t fit in Android Studio’s LogCat console window cleanly.

So I created this function that would take any string break it into smaller chunks for better output. Enjoy!

Java

public final class DebugUtilis {

    public static int _charLimit = 2000;

    public static int v(String tag, String message) {

        // If the message is less than the limit just show
        if (message.length() < _charLimit) {
            return Log.v(tag, message);
        }
        int sections = message.length() / _charLimit;
        for (int i = 0; i <= sections; i++) {
            int max = _charLimit * (i + 1);
            if (max >= message.length()) {
                Log.v(tag, message.substring(_charLimit * i));
            } else {
                Log.v(tag, message.substring(_charLimit * i, max));
            }
        }
        return 1;
    }
}

Kotlin

object DebugUtilis {
    var _charLimit = 2000
    @JvmStatic
    fun v(tag: String?, message: String): Int { 
        // If the message is less than the limit just show
        if (message.length < _charLimit) {
            return Log.v(tag, message)
        }
        val sections = message.length / _charLimit
        for (i in 0..sections) {
            val max = _charLimit * (i + 1)
            if (max >= message.length) {
                Log.v(tag, message.substring(_charLimit * i))
            } else {
                Log.v(tag, message.substring(_charLimit * i, max))
            }
        }
        return 1
    }
}

Break-up Very Long LogCat Message was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

No, I’m not talking bio-metric security. I am talking about about app authority and security.

What is it?

The short answer is — it is a method of authenticating your app. The long answer is — the fingerprint is used to sign certificates, sign data that gets sent over the Internet, and validate information it may receive from 3rd-parties.

What is is used for?

Many services require your app’s fingerprint as a method for verification to use their service. Services such as Square and Google Maps use your app’s fingerprint during their certificate signing. This helps to thwart would-be imitators from impersonating your application to access their platform.

Your app generally has two fingerprints — a debug version and a release version. Which one you supply to whatever service you are using that requires it, will depend upon what environment you’re working in. Obviously, if you are tinkering around in a sandbox, you’ll use the debug version and when you’re ready to go live, the release version.

It sometimes goes by other names that you have probably searched for as well:

• Signed Certificate Fingerprint
• Android SHA-1 Certificate
• Android SHA-256 Certificate

The Command Line

Open your Terminal (Mac) or Command Prompt (Mac)

The general formula goes something like this:

keytool [options] -keystore PATH_TO_KEYSTORE  -alias ALIAS_NAME

keytool is the command line program used to access and manipulate the keystore file.

PATH_TO_KEYSTORE is the full path to where your Android Apps keystore is. Typically stored in safe place outside of your app project. I keep mine in a secure storage, since I only use it to sign my apps when it is time to deploy or publish a new version. Never store your keystore file in the cloud! If someone gets it, they can create new apps and sign them as if they are yours.

ALIAS_NAME is a unique identifier that helps you locate the specific key your looking for, usually the name of your app. If a keystore is a phone book, then ALIAS_NAME would be the person you are looking up and the fingerprint would be the phone number. Aliases are case-insensitive; so MyGreatApp and mygreatapp would refer to the same entry.

Finding Your Production Fingerprint

An example if the key store was located on my desktop:

keytool -list -v -keystore /Users/adammcelhaney/Desktop/adams.keystore  -alias MyGreatApp_Alias_Production

You’ll be asked to enter the password you used when you generated the keystore, so have it handy.

(adammcelhaney):> ~/Desktop/GitHub/MyGreatApp: keytool -list -v -keystore /Users/adammcelhaney/Desktop/adams.keystore  -alias MyGreatApp_Alias_Production

Enter keystore password:

Alias name: MyGreatApp_Alias_Production
Creation date: Jan 22, 2020
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner:  CN=Adam McElhaney, OU="MyCompany, Inc", O="MyCompany, Inc", L=New York City, ST=New York, C=US
Issuer: CN=Adam McElhaney, OU="MyCompany, Inc", O="MyCompany, Inc", L=New York City, ST=New York, C=US
Serial number: 4f393733
Valid from: Mon Jan 22 08:15:00 EST 2020 until: Fri Jul 01 11:59:59 EDT 2040
Certificate fingerprints:
 MD5:   AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99
 SHA1:  99:88:77:66:55:44:33:22:11:00:FF:EE:DD:CC:BB:AA:99:88:77  
 HA256: 00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22
    Signature algorithm name: SHA1withRSA
    Version: 3

Depending upon what level of encryption is needed by the service requiring your app’s fingerprint, you’ll see usually three different fingerprints. MD5, SHA1 and HA256.

The hex code looking value is what you’re after. 99% of the time it’s the SHA1.

Debug Fingerprint

Same idea as above, though Android Studio will automatically generate a debug version of your fingerprint for you. Usually stored in ~/.android\debug.keystoreif you’re on a Mac and C:\Users\USERNAME\.android\debug.keystore if you’re on Windows.

keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

Using Android Studio

Another way, is to use the Gradle task in Android Studio.

From within Android Studio, on the right side of the IDE click the Gradle button along the side — Gradle is in vertical lettering. This will show the Gradle tasks pane. Under your MyGreateApplication > Tasks > android you will see a signingReport task. Right-click it and select Run.

This will show you all your fingerprints. Take note of the Variant value when you go to copy keys.

Enjoy!

Finding Your Android App’s Fingerprint in 2020 was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

I sometimes need to take a high resolution screenshot of an entire website for a print publication.

I am using Firefox for this example. I’m sure it could be adapted for other browsers.

From within Firefox, from the main menu, click Tools > Web Developer > Style Editor (or Shift + F7).

This will open a new section with a bunch of CSS code. Make sure the first CSS file is selected (it will be different based upon your site) and at the top of the file paste:

body {
  zoom: 4;  /* zoom factor */
  -moz-transform: scale(4);  /* same zoom factor */
  -moz-transform-origin: 0 0;
}

I am using 4 as the zoom factor which translates to 400%. Typically, a screenshot is at 72dpi. This zoom level puts us closer to 288dpi —much closer to the standard 300dpi for print or other applications.

Next, click the Console tab in the same window and at the prompt type the below command. That’s two dashes (-) in front of the word fullpage.

:screenshot --fullpage

Give it a moment and you’ll see a message telling you where your new screenshot is.

Enjoy your new high-resolution screenshot. You can either refresh the page or delete the CSS code we added to go back to normal.

Quick tip: Take High Resolution Full Page Screenshots was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

I’m going to show you how to use the Mailable class that was first introduced in Laravel 5.3. To help keep this tutorial clean, I am going to omit any comments, namespaces, or any top level use statements generated by Laravel.

Prerequisites

You will need:
1. A Laravel 6 project setup
2. Your email provider credentials in your .env file or other configuration file.

We want to send a welcome email to a user thanking them for signing up. This is only an example how I am calling the Mailable, you can call it from wherever you need to.

In my NewUserController, after my user is created, I am going to send the welcome email. I am also want to pass the User object to Mailable, since it has the new user’s name, email address and many other properties that I might want to include in the email.

public function store(){
 $user = User::create($request);
 
 // Send email here 
}

Creating the Blade view files

It is best practice to create two files for email, a plain text version and an html version. The plain text ensures that your email is readable everywhere by most helper services, like Apple Watch or other preview panes. The html version is what most people will see when the open the email to read it.

Inside your resources > views folder, create a new file called welcome_email and welcome_email_plain.

Open welcome_email_plain first. I find it easier to focus on just the content and layout in the plain text first so I can organize the information like I want. Afterward opening the html version and just apply styling. I am going to show the creation of the plain text version. Just assume that I have copied and pasted from the plain version to html version.

$data is the name of the public property we will create in the WelcomeMailable class in a moment. It will be filled with the $user object from inside the controllers store() method. My user model has a first_name, last_name, email_address, user_name and the timestamps.

Hello, {{$data->first_name}} {{$data->first_name}}

You signed up on {{$data->created_at}}.

Your login id is {{$data->email_address}}

Thank you!

Now would be the time to copy your plain text email and then paste and style it in your html file.

Creating the Mailable class

Open Terminal and use the make command

php artisan make:mail WelcomeMailable

This will place the a new file in your \App\Mail folder.

Open it up so we can begin editing it. From before we know we are going to be passing a User object to this class so we can fill the email with information. Start by add public property called $data. Add $data to the constructor and set the class’s data property.

class WelcomeMailable extends Mailable
{
 use Queueable, SerializesModels;
 public $data;

 public function __construct($data){
      $this->data = $data;
 }

 public function build(){
   return $this->from(‘welcome@mysite.com’)
               ->bcc(‘me@site.com’)
               ->subject(‘Welcome To Our Site’);
               ->view(‘welcome_email’)
               ->text(‘welcome_email_plain’)
               ->with($this->data);
 }
}

In the build() method, I am overriding the Mail class’s default from by chaining from() and passing in an email address that I want the email to have appeared to come from. This is completely optional. I have noticed a lot of sites use emails like ‘welcome@site.com’ and ‘support@site.com’. They usually come with the disclaimer “Please do not reply to this email address, as it is an unattended mailbox.”. This is usually a reason why.

I also want to be notified when a new user is created, so I just blind carbon-copy bcc() myself and set the subject line.

I then supply the view() with the name of the html blade version of our email file created. And the text() takes the plain version. I am using with() to pass in our $dataproperty that will populate the email.

Returning to the store() method (or whatever controller you are using) and add use Illuminate\Support\Facades\Mail; at the top so the class can have access to the Mail facade.

Jump to the store() function and below the new user creation line, let’s call add the call to our new Mailable class and pass in the $user object.

public function store(){
 $user = User::create($request);
 
 // Send email here 
 Mail::to($user->email_address)->send(new WelcomeMailable($user));

}

That’s all there is to it! Next time you have a new user created they will be sent a welcome email and you will be notified also.

Sending Email In Laravel 6 was originally published in Self Modifying Code on Medium, where people are continuing the conversation by highlighting and responding to this story.