Steps to follow

Step 1: We need to have a running AEM Author and Publish instance. You can also use local author and publish instances for simplicity. If you are deploying to a server, the steps are mostly the same.

Step 2: We need to install Jenkins using Docker. You can install Docker by following this article.

Once Docker is installed, run this command in the terminal -

docker run -d -p 8080:8080 -p 50000:50000 --name jenkins jenkins/jenkins:lts

This command will install Jenkins using Docker on port 8080, and you can access it from your browser. If it's on your local machine, try using localhost:8080, or use serverIP:8080 if it's on a server.

Step 3:

When you open localhost:8080, you'll see a message like the image below, prompting you to access the admin password to continue.

To get the root password, run the following command in the terminal.

docker exec -it jenkins cat /var/jenkins_home/secrets/initialAdminPassword

It will output the admin password, use it to proceed in jenkins.

Next, install the suggested plugins option. It will take few minutes, and all the plugins will get installed. These include plugins like git, dark mode, credentials manager, etc.

It will now ask you to fill username and password. Create a user and proceed.

Step 4:

Once done go to the http://localhost:8080/manage/ and click on Plugins, we have to search and select “Maven Integration plugin” from this list (refer below image)

Step 5:

Once done with installation, go to http://localhost:8080/manage/configureTools/ and scroll below, and go to “Maven Installations”, and select the maven version from the list and save.

Step 6:

Now, we also need to securely pass our credentials to the pipeline. To do this, go to http://localhost:8080/manage/credentials/store/system/domain/_/ and add new credentials there. Make sure to note the ID, as we will use this ID in our pipeline syntax, allowing Jenkins to pass the credentials securely. In my case i have saved my bitbucket(git) credentials to checkout the code, and then aem credentials to upload the package. These two are required for this script execution.

Step 7:

Now, come back to main page http://localhost:8080/ , click on “Create Job” and then provide a name to this item “Local AEM Build and Deploy” and select “Pipeline”

Pipeline is the simplest option, but we can choose other options too, depending on the use case, such as "Multi Branch Project." For simplicity, we have selected "Pipeline" for this topic.

Now, you have several options available, and most of them are easy to understand. For this tutorial, scroll down to the end and add the script below in the pipeline script option.

You might need to make some changes based on your use case, such as replacing the correct Maven name you provided in the tools section in Step 5.

Update the AEM_HOST IP or set it to “localhost” if AEM is running locally.

In case jenkins is running on docker, and aem is running on mac/windows, we have to use “host.docker.internal” to access the aem machine from docker jenkins

Depending on the publisher status, you can comment out or remove the “Deploy to Publisher” stage from the script.

Update the correct Git URL of your repository in the “Checkout” step.

pipeline {
    agent any
    tools {
        maven 'maven-3.9.11'
    }
    environment {
        AEM_HOST = "172.104.206.123"
        AUTHOR_AEM_PORT = "4502"
        PUBLISHER_AEM_PORT = "4503"
        AEM_PACKAGE = "all/target/colorful.all-1.0.0-SNAPSHOT.zip"
    }

    stages {
        stage('Checkout') {
            steps {
                git branch: 'master',
                        credentialsId: 'bitbucket-credentials',
                        url: 'https://the-colorful-slate@bitbucket.org/the-colorful-slate/colorful-aem.git'
            }
        }

        stage('Build Package') {
            steps {
                sh """
                mvn clean install
                """
            }
        }

        stage('Archive Package') {
            steps {
                archiveArtifacts artifacts: "${AEM_PACKAGE}", fingerprint: true
            }
        }

        stage('Deploy to AEM Author') {
            steps {
                // Inject AEM credentials securely
                withCredentials([usernamePassword(
                        credentialsId: 'aem-credentials',
                        usernameVariable: 'AEM_USER',
                        passwordVariable: 'AEM_PASS'
                )]) {
                    sh """
                        mvn com.day.jcr.vault:content-package-maven-plugin:1.0.2:install \
                          -Dvault.file=${AEM_PACKAGE} \
                          -Daem.host=$AEM_HOST \
                          -Daem.port=$AUTHOR_AEM_PORT \
                          -Dvault.user=$AEM_USER \
                          -Dvault.password=$AEM_PASS
                    """
                }
            }
        }

        stage('Deploy to AEM Publisher') {
            steps {
                // Inject AEM credentials securely
                withCredentials([usernamePassword(
                        credentialsId: 'aem-credentials',
                        usernameVariable: 'AEM_USER',
                        passwordVariable: 'AEM_PASS'
                )]) {
                    sh """
                        mvn com.day.jcr.vault:content-package-maven-plugin:1.0.2:install \
                          -Dvault.file=${AEM_PACKAGE} \
                          -Daem.host=$AEM_HOST \
                          -Daem.port=$PUBLISHER_AEM_PORT \
                          -Dvault.user=$AEM_USER \
                          -Dvault.password=$AEM_PASS
                    """
                }
            }
        }
    }

    post {
        success {
            echo '✅ Build & Deploy successful!'
        }
        failure {
            echo '❌ Build failed!'
        }
    }
}

Once finished, you can click on "Build Now" to start running the Jenkins pipeline. You will see a similar page once it is completed.

That's it! We successfully set up Jenkins on Docker, checked out the AEM code from Git, and deployed it to running AEM instances.

Do comments, if you face any issue while implementing this. 🚀🚀🚀

This can have a significant impact on key business metrics such as conversion rates, time spent on a site, and lower bounce rates, as images are often a major contributor to page load time.

Smart Imaging in Dynamic Media Classic enhances image delivery performance by automatically optimizing image format and quality based on client browser capabilities. It reduces image sizes by 30 percent or more.

If you are using AEM Sites and have Dynamic Media available to you, you can take advantage of Smart Imaging.

Smart Imaging technology applies Adobe Sensei AI capabilities and works with existing "image presets".

How does Smart Imaging Operate?

When an image is requested by a consumer, Smart Imaging checks the user characteristics and converts it to the appropriate image format based on the browser in use. These format conversions are done in a manner that does not degrade visual fidelity. Smart imaging automatically converts images to different formats based on browser capability in the following manner.

• Automatically convert to AVIF if the browser supports the format.

• Automatically convert to WebP if AVIF conversion is not beneficial or the browser does not support AVIF.

• Automatically convert to JPEG2000 if Safari does not support WebP.

• Automatically convert to JPEGXR for IE 9+ or if Edge does not support WebP.

Steps to How To Use Smart Imaging

Step 1:- Enable Smart Imaging

You need to create an Adobe support ticket to enable Smart Imaging on your account. More details on the support ticket

Adobe support person will enable a domain for like as mycompany.scene7.com or images.company.com and not a generic domain, such as s7d1.scene7.com, s7d2.scene7.com, s7d13.scene7.com

Step 2: Verify Domain

To find your domains, open the Dynamic Media Classic desktop application, then sign in to your company account or accounts. Go to Setup > Application Setup > General Settings.

Look for the field labeled Published Server Name. If you are currently using a generic Dynamic Media Classic domain, you can request moving over to your own custom domain as part of this transition.

Step 3: Re-Configure Dynamic Media General Settings

To utilize the smart image domain within AEM. You have to change the Published Server Name in Dynamic Media General Setting.

Go to aem/start.html > Tools > Assets >Dynamic Media General Settings\> change the Publish server Name to smart image domain.

Note: You need to reprocess your assets to utilize this smart image domain

Step 4: Validation

1. After your account is configured with Smart Imaging, load the Dynamic Media image URL on the browser.

2. Open the Chrome developer pane by going to View > Developer > Developer Tools in the browser. Or, choose any browser developer tool of your choice.

3. Ensure that the cache is disabled when developer tools are open.

   • On Windows®, navigate to settings in the developer tool pane, then select the Disable cache (while devtools is open) check box.

   • On macOS, in the developer pane, under the Network tab, select disable cache.

Once Smart Imaging is enabled, after you request an image, under the Response Headers you will see the Request URL and -X-Adobe-Smart-Imaging as seen in the above highlighted example:

This response header tells you the following

• Smart Imaging is working.

• A positive value means that the conversion is successful. In this case, a new WebP image is returned.

• A negative value means that the conversion is not successful. In such a case, the original requested image is returned (JPEG by default, if not specified).

• A positive value shows the difference in bytes between the requested image and the new image. In the example above, the bytes saved is 62689 or approximately 62 KB for one image.

• A negative value means that the requested image is smaller than the new image. The negative size difference is shown, but the image served is the original requested image only.

Key benefits of Smart Imaging?

1. Image Optimization: Smart imaging technologies can automatically optimize images for various factors like size, format, and quality. This leads to improved website and app performance, faster loading times, and reduced bandwidth usage.

2. Enhanced User Experience: Optimized images ensure a better user experience by reducing page load times and providing visually appealing content, which can increase user engagement and reduce bounce rates.

3. Responsive Design: Smart imaging can adapt images to fit different screen sizes and resolutions, making websites and apps more responsive and accessible across a wide range of devices.

4. Improved SEO: Optimized images with proper metadata and alt tags can enhance search engine optimization (SEO) efforts, leading to better visibility and rankings in search results.

5. Bandwidth Efficiency: By reducing image sizes, smart imaging minimizes data consumption, benefiting users with limited bandwidth or on slower networks. This can be especially crucial in mobile applications.

6. Quality Retention: Despite image compression and optimization, smart imaging technologies aim to maintain image quality, ensuring that visuals remain sharp and clear.

7. It Serves optimized content immediately (at runtime).

In summary, smart imaging plays a crucial role in optimizing digital content, improving user experiences, reducing costs, and enhancing various aspects of web and app development and management.

It's impressive how Smart Imaging does all the work on its own, and consumers don't need to do anything—it's effortless and smooth.

Note: Smart Imaging requires that you use the out-of-the-box CDN (Content Delivery Network) that is bundled with Adobe Experience Manager - Dynamic Media. Any other custom CDN is not supported with this feature.

If you have any questions, please don't hesitate to ask! Linkedin

A system user is typically utilized by the AEM backend code which has privileges to create, read, update, and delete nodes in the JCR using a session.

Developers have to close the session after the tasks are performed.

If you forget to close the sessions that you've opened, your AEM can get overwhelmed with too many open sessions. This can cause your AEM to run out of memory and crash. In simpler terms, not closing sessions properly can lead to memory issues and system crashes in AEM.To learn more about this topic, take a look at this blog How to Close ResourceResolvers, and Sessions

How to create a system user or service User

Creating a service user in Adobe Experience Manager (AEM) as a Cloud Service requires configuring the RepositoryInitializer

What is repoinit (RepositoryInitializer configuration)?

Repoinit is a tool for setting up a content repository in a specific way. It is like a recipe that tells the repository how to create nodes, properties, service users, and access control policies, as well as register JCR namespaces, node types, and privileges.

Full documentation is found here.

Here is a simple example of a repoinit script:

{
    "create node /content/my-site"
    "create property /content/my-site/title "My Site"
    "create service user mySystemUser"
    "grant permission to mySystemUser to read and write /content/my-site"
}

Here are the steps to create a service user in AEM Cloud:

Steps 1: Set up the "org.apache.sling.jcr.repoinit.RepositoryInitializer" PID configuration.

filename: apps/mysite/osgiconfig/config/org.apache.sling.jcr.repoinit.RepositoryInitializer~mySystemUser.cfg.json

{
  "scripts": [
    "create path (sling:OrderedFolder) /content/dam/mysite",
    "create path (nt:unstructured) /content/dam/mysite/jcr:content",
    "create path (cq:Page) /content/mysite",
    "create path (cq:PageContent) /content/mysite/jcr:content",
    "create path (sling:Folder) /conf/mysite",
    "create service user mySystemUser with path /home/users/system/mysite",
    "set ACL for mySystemUser \r\n  allow jcr:all on /content/mysite\r\n  allow jcr:all on /conf/mysite\r\n  allow jcr:all on /content/dam/mysite\nend"
  ]
}

Description of Step 1:

This script enables the creation of a system user named "mySystemUser," which will be situated within the folder structure at /home/users/system/mysite.

The system user, mySystemUser, will have ACL (Access Control List) privileges configured to:

• allow read, write, and replicate for all JCR resources that exist under /content/mysite

• allow read, write, and replicate for all JCR resources that exist under /conf/mysite

Steps 2: Set up the "org.apache.sling.serviceusermapping.impl.ServiceUserMapperImpl.amended " PID

filename:

apps/mysite/osgiconfig/config/org.apache.sling.serviceusermapping.impl.ServiceUserMapperImpl.amended~mySystemUser.cfg.json

{
  "user.mapping": [
    "mysite-core.core:mySystemUser=[mySystemUser]"
  ]
}

Deployment: -

Make this change and deploy it locally, you will able to see the service or system user inside this folder (/home/users/system/mysite)

Note: If you are not able to see system users in your local please restart your AEM.

Sample code to get a resource resolver using mySystemUser as the Sling sub-service

final Map<String, Object> authInfo =
        ImmutableMap.of(ResourceResolverFactory.SUBSERVICE, "mySystemUser");
try (ResourceResolver resolver =
        resourceResolverFactory.getServiceResourceResolver(authInfo)) {

    final Resource blog = resolver.getResource("/content/mysite/blog");
    logger.info("got {}", blog.getPath());

} catch (LoginException e){
    logger.error("could not open resource resolver", e);
}

Common Errors occurs related to repoinit configurations in AEM :

Sometimes you may find that your AEMaaCS pipelines are failing due to the repoinit

To Troubleshoot that error please check the below points

1. Syntax Errors: Incorrect syntax in repoinit scripts can lead to parsing errors. Ensure that the script is properly formatted and follows the repoinit language rules.

2. Invalid Paths: If the paths specified in repoinit scripts do not exist or are incorrect, you may encounter errors when trying to apply the configuration.

3. Access Denied: Insufficient permissions for the user executing the repoinit script can result in errors when trying to make changes to the repository.

4. Node Overwrite: If the repoinit script attempts to create a node that already exists without specifying whether it should be overwritten, it can cause errors.

5. Incompatible Actions: Some actions specified in repoinit scripts may be incompatible with the existing repository state or configurations. This can lead to conflicts and errors.

6. Timing Issues: Repoinit scripts are executed during repository startup or when triggered manually. If the script depends on certain conditions that are not met at the time of execution, errors can occur.

7. Resource Dependencies: If the repoinit script relies on external resources (e.g., files, services) that are unavailable or misconfigured, it can result in errors.

8. Logging and Debugging: Inadequate logging and debugging in the repoinit script can make it challenging to diagnose and troubleshoot errors.

9. Conflict Resolution: If multiple repoinit scripts are applied, they may conflict with each other or with existing repository configurations. Resolving these conflicts is essential to prevent errors.

10. Version Compatibility: Repoinit scripts may not be compatible with the version of AEM being used, leading to errors or unexpected behavior.

To address these issues, it's crucial to thoroughly review and test your repoinit scripts, ensure that they align with your AEM environment's requirements, and monitor the logs for any error messages or warnings during script execution. Additionally, refer to the official AEM documentation and best practices for repoinit configuration to avoid common pitfalls.

If you have any questions, please don't hesitate to ask! Linkedin

So, here are the steps to go through to tail logs on an AEM as a Cloud Service environment:

Step 1: Set up Adobe I/O CLI

Launch the Command Prompt/Terminal and install Adobe I/O CLI. More details on Adobe IO CLI here

Check whether Node is installed or not if it's not please install. More details on installation Node

$ npm install -g @adobe/aio-cli

Post Install of adobe/ aio-cli

$ aio info
output: - 
rj00752505@BGINCHAMLP00792 ~ % aio info

  System:
    OS: macOS 13.4.1
    CPU: (10) arm64 Apple M1 Pro
    Memory: 87.38 MB / 16.00 GB
    Shell: 5.9 - /bin/zsh
  Virtualization:
    Docker: Not Found
  npmGlobalPackages:
    @adobe/aio-cli: 9.3.0

Step 2: Configure the Adobe IO Cloud Manager CLI Plugin

Installation

aio plugins:install @adobe/aio-cli-plugin-cloudmanager

Updating

$ aio plugins:update

Step 3: Authentication

a) Browser-Based Authentication - Browser-based authentication starts by running this command.

aio auth:login

This command will open a browser window in which you will authenticate using your Adobe Identity.

Note: You can choose any type of authentication***.***

b) Service Account Authentication To use a service account authentication, an integration (aka project) must be created in the Adobe I/O Console which has the Cloud Manager service.

The required type of server-to-server authentication

{
  "client_id": "value from your CLI integration (String)",
  "client_secret": "value from your CLI integration (String)",
  "jwt_payload": { value from your CLI integration (JSON Object Literal) },
  "token_exchange_url": "https://ims-na1.adobelogin.com/ims/exchange/jwt"
}

Step 4: Setting Up the Default Program and Default Environment

To Find the Env and Program id - Navigate to my.cloudmanager.adobe.com, you’ll see a URL after logging in like “https://experience.adobe.com/#/@the_cool_name_of_my_company/cloud-manager/home.html/program/{PROGRAM_NUMBER}”

$ aio config:set cloudmanager_programid 34562 // setting up default program
$ aio config:set cloudmanager_environmentid 124551 //setting up default env

Useful Command

1. To List list all the program

$ aio cloudmanager:list-programs

 Program Id    Name                Enabled 
 ────────── ───────────────────── ───────  
 43674       sandbox-B2c              true    
 34562       sandbox-B2b              true

1. To List all the Environments

$  aio cloudmanager:list-environments 

 Environment Id Name                                  Type  Description       
 ────────────── ───────────────────────────────────── ───── ─────────────────
 124551          demo                          dev   dev environment n          
 9845628         demo-prod                     prod  prod   This is prod env.

1. To List list all the log-options

$ aio cloudmanager:list-available-log-options 124551 
 Environment Id Service            Name          
 ────────────── ────────────────── ───────────── 
 124551         preview_dispatcher httpdaccess   
 124551         preview_dispatcher httpderror    
 124551         preview_dispatcher aemdispatcher 
 124551         author             aemaccess     
 124551         author             aemerror      
 124551         author             aemrequest

4)To Tailing the Author error log

$  aio cloudmanager:tail-log 121351 author aemerror
25.09.2023 15:34:56.428 [cm-p33452-e121351-aem-author-54c7ddc56c-vf8vb] *INFO* [sling-oak-observation-5] com.adobe.cq.ups.user.utils.UserCreationListener UPS Feature is disabled
25.09.2023 15:34:56.452 [cm-p33452-121351-aem-author-54c7ddc56c-vf8vbJ *INFO* [188.24.112.253 [1695656096450] GET /mnt/overlay/granite/ui/content/shell/header/actions/pulse.data.jsonHTTP/1.11com.day.ca.wcm.core.imp1.designer.searchPathlimiter
Search path limiter configured with searchPathLimiterFeatureToggleOn: true and searchPathThreshold: true
25.09.2023 15:34:56.469 [cm-p33452-e121351-aem-author-54c7ddc56c-vf8vb] *INFO* [188.24.112.253 [1695656096468] GET /mnt/overlay/granite/ui/content/shell/header/actions/pulse.data.jsonHTTP/1.11com.day.cq.wcm.core.imp1.designer.SearchPathLimiter
Search path limiter configured with searchPathLimiterFeatureToggleOn: true and searchPathThreshold: true.

Similarly, you can tail any logs.

If you have any questions, please don't hesitate to ask! Linkedin

Groovy example below contains an XPath query that finds all the pages under "/content/geeksdemo" with template "/conf/geeksdemo/settings/wcm/templates/page" and adds a deny permission of delete to the admin-test group members.

Same way, other permissions under the Privilegeinterface can be added.

That's a wrap. Let me know your feedback on this. Please follow for more such tricks and tutorials.

Now, on the internet, we know there are many websites that provide free temporary email addresses. No doubt those email addresses will do your job, but there are some disadvantages to them, such as they are temporary addresses so cant be used for the long term, second you need to create those addresses beforehand to fill in the website. Now, as this trick is very well known, many sites block addresses from these websites' domain names.

There is another way to generate an unlimited Gmail email address by adding a (+) plus sign. for example - abc+xyz@gmail.com or abc+123@gmail.com, these all will go to abc@gmail.com. This method will work on most sites if they don't have a check on plus sign with gmail.com addresses.

Cloudflare Trick: We will use the free domain from the freedom website for this tutorial, if you already have a domain name registered with Cloudflare, then go to step 3.

Step 1: Get Free Domain Name: Go to freenom. com, and register for an account. Once login to the website, search for a domain name that is available, then select the .tk option and checkout. This domain is free of cost and valid for 1 year. On the checkout page, you can change the duration from 3 months to 12 months and then proceed for checkout. You will get your free domain name now.

Step 2: Login or create a Cloudflare account. Add your domain name to the Cloudflare dashboard. Now, Cloudflare will search for the existing domain name record for this domain and then ask you to modify it to point to Cloudflare name servers. Copy the name servers from Cloudflare, and go to freedom, domain management and replace the name servers. You need to wait for a few minutes till Cloudflare picks the new changes.

Step 3: Now, go to the email section of Cloudflare, it will show some records are missing, you can click on a skip for now. Click on the Route tab and then click on Enable Email Routing. Cloudflare will show some options you just need to accept those recommendations and apply. Finally, it will give you an "Email Routing is enabled and routing emails." message.

Step 4: All set to create email addresses. Go to the Routes tab and scroll to the destination email address section, add your email address where you want to receive all emails for this domain. Once you verify the destination email address

Go to the "Catch-all address" section and enable it, click on edit and select send to option and from the next drop down select your email address which you have verified. Click Save.

Now, you are set to use any email address from this domain. Like if you receive an email on hashnode@domainname.tk, devto@domainname.tk, or medium@domainname.tk. These all will land in your primary email address which you verified in cloudflare.

Now, while signing up on any website, you can add any email address on that website and the email will land on your webmail.

That's a wrap. Let me know your feedback on this. Please follow for more such tricks and tutorials.

Slack Account

You need to have a slack account to follow this tutorial, you can create a free account from here Join Slack

Once we create or log in to the slack workspace, we need to get an email address where we can forward the unread emails from Gmail.

Follow the steps from this slack article

Google Script Account

As we are going to use google script API to pull emails, please log into your google account and then go to Google Script. Click on New Project on the top left screen.

A new script editing window will open, remove the dummy code and paste the below code. Save the script, and provide a name to the project.

function fetchUnreadGmailAndSendToSlack() {
  var threads = GmailApp.search('is:unread');
    for (var i = 0; i < threads.length; i++) {
        console.log("found message with subject :: "+threads[i].getMessages()[0].getSubject());
        threads[i].getMessages()[0].forward('email-id-from-slack@team-name.slack.com');
        threads[i].getMessages()[0].markRead();
        console.log("Mail forwareded to slack.");
    }
   console.log("finished.");
}

function doPost(request){
  fetchUnreadGmailAndSendToSlack();
  console.log(request);
  var responseContent = '{"text": "Message Received, Bots are Working On ! "}';
  var response = ContentService.createTextOutput(responseContent);
  response.setMimeType(ContentService.MimeType.JSON);
  return response;
}

On line number 5, please change the email id to your slack email id received from the above step.

In this code there are two methods, as Slack makes a POST request, we have created one doPost() which will receive the request and call the fetchUnreadGmailAndSendToSlack() method. It will also reply back in the slack chat with a success message, which will indicate the request is processed successfully. fetchUnreadGmailAndSendToSlack this method will search for the unread emails using Gmail APP API. Once it finds the list, it will iterate through those emails and forward them to provided slack mail-id and then mark them as read.

Now, that we are done with coding, we need to deploy this script and get the URL using which we can execute it. Click on the Deploy button on the top right, then select New deployment. Here as it's our first deployment, we need to tell google which kind of script is this, so select the type as Web app.

Then write some description, select your email id in the Execute as an option, this will make sure, whenever this script is run it will use your access, and in the last drop-down select anyone under "Who has access". Click Deploy, and then authorize. It will ask you to then select your google account, a warning will pop up, click on advanced, and then click on your project name.

A similar screen should come up, copy the Web app URL. Anyone with this endpoint can trigger your script.

Head Back to Slack

As we have our script which will pull the unread email, we need to create an app on Slack to access this script using our slash commands. Go to this Slack APP URL, click on the Create New App Button, select from scratch, enter details and click create.

Now, we need to set slash commands, which will invoke our google script.

Click on Create New Command and fill details. Text which you enter in the command box will be used to invoke this app, whereas in the Request URL enter your Google Web app Deployment URL. Add short description and hit save.

One Last Step is to install this app in your workspace. Under Settings, select Install App, authorize the app by selecting the workspace.

Now, we are all set to pull our unread emails directly in slack. So, go to slack chat and invoke this app by typing / and then your command entered above in any chat window. In my case its /supermanfetchemails

You should see a message in the chat as **Message Received, Bots are Working On! ** and unread emails must have arrived from the slack bot chat.

Now whenever you need to find your un-read emails from Gmail, you call your own superman bot. Further customization can be done in google script, as Gmail APP Api provides multiple functions.

That's a wrap. Let me know your feedback on this.

In these all examples, we have considered our Index name as Cat.

1. To get all the Indexes in the Elastic, use this.

GET /_cat/indices?h=index

2. Now, to create an Index in Elastic, make a PUT request with the index name.

PUT cat

3. To get the Index Mapping, use

GET cat/_mapping

4. Delete Index- In case you want to remove an index altogether, just make a delete request in Kibana with the index name.

DELETE cat

5. Reindexing-Sometimes you will face an issue, where you have to copy all the documents from one index to another. So, in that case, _reindex will come in the picture, just enter the source and destination index name, it will copy the documents. You can also add ingest pipeline option, in case you want all your documents to run through this pipeline before indexing, this is optional.

POST _reindex
{
  "source": {
    "index": "cat"
  },
  "dest": {
    "index": "cat_backup",
    "pipeline": "some_ingest_pipeline"
  }
}

6. Delete one document- In case you want to delete a document from one of the indexes, just follow the below API syntax.

DELETE  cat/_doc/123456789

Now, As you are up and running with the Elastic Index creation. Let's talk about a few requests with basic elastic search queries. 7. To delete documents matching specific conditions, use Delete By Query calls.

POST /cat/_delete_by_query
{
  "query": {
    "match_all": {}
  }
}

8. Get count of all Documents, in an index.

GET cat/_count

9. To search for documents with id.

GET cat/_search
{
  "query": {
    "match": {
      "_id": "97351395-2241-4287-953e-6987dbf93827"
    }
  }
}

10. The above query will return all the fields of the document, but in case you only need some specific fields. Use the query with _source key, which allows us to pass the fields which we need in the document.

GET cat/_search
{
  "_source": [
    "title",
    "description"
  ],
  "query": {
    "match": {
      "_id": "97351395-2241-4287-953e-6987dbf93827"
    }
  }
}

11. If you are not aware of the field, where you will get the search term, and want to search all the fields for the search text, then use query_string

GET cat/_search
{
    "query": {
        "query_string": {
           "query": "kiwi"
        }
    }
}

12. To search for the exact terms, use match_phrase.

GET cat/_search
{
  "query": {
    "match_phrase": {
      "name": "deals of the day"
    }
  }
}

13. To search for the parent document using child, try the below request.

GET cat/_search
{
  "query": {
      "parent_id": {
          "type": "child",
          "id": "00000001"
      }
  }
}

14. Using the below query, you can search for a document, where the colour field is either black or white, whereas the breed is Persian.

GET cat/_search
{
  "query": {
    "bool": {
      "must": {
        "match": {
          "breed": "Persian"
        }
      },
      "should": [
        {
          "match": {
            "color": "black"
          }
        },
        {
          "match": {
            "color": "white"
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

15. In case you are using any analyzer in the index, so to verify how search terms will behave use analyze requests. As result, you will get the tokens, on which the actual search will take place.

GET cat/_analyze
{
  "analyzer": "ascii-stop-analyzer",
  "text": "açaí a la carte"
}

That's a wrap, for now, Further, I will update this post with the component template, index template, Ingest Pipeline and Index Mapping.

Please Ignore the spacing issue in query JSONs because of the markdown format.

Important Links:

1. Elastic Documentation.

2. Elastic Quick Start

3. Parent child relationship

Step 1: Getting Credentials from NASA Open API

As we are going to pull our Images from NASA Open source API, which in turn gets these Images from Mars Rover. So, let's first visit https://api.nasa.gov/, Here we have to enter few details, and it will give us an API Key to access its APIs.

After entering all details, you should see the below screen, where API Key will be shown, please note this carefully, we will need it.

Now, from the menu, select Browse APIs and enter Mars in the search box, you should see all mars related APIs.

Now, we are going to use the below API, which sends us random Image Data every time we change the SOL number.

https://api.nasa.gov/mars-photos/api/v1/rovers/curiosity/photos?sol=12&api_key=DEMO_KEY

Replace the DEMO_KEY with your API Key.

This Endpoint returns a Photos Array, which contains all information. we will be traversing it and finding the Image Endpoint.

Okay, So we have all the info which we needed from NASA.

Step 2: Code our Python Bot

We will first get the Twitter API keys, for that go to this URL Developer Portal and follow the process, which is self-explanatory. In the end, you should have your Access Key and Consumer Key. (Do let me know in the comments if you face any issues.)

Let's start coding. 😈

First Lets import the tweepy and other libraries, and set the Twitter keys in a variable. I have used config variables, as I am going to deploy it to a Server Later on, you can directly assign the values, for local development.

Now, try to make a connection with Twitter, If all goes well you should see the "Connection Done!" message, in the terminal.

Now, as we are connected to Twitter, let's try to pull the Image from NASA API, which we are going to use. First, we are getting the current date and time, and printing it out. Next, we are trying to fetch a random Integer, if you remember in NASA API, we need to pass a random SOL. So, we will add this number in the API Url, and make a get request. If the request code is 200, we will start reading the response, or else will print an error message.

As our Image URL is in the photos array, we will save this array in photos_array, and as you can see in the response, there are multiple images object in the array, so let's pick a random object from the array by again using the random library. Once we found the Image, pass the message and image to another function, from where we will actually update the Twitter status.

This function is very simple, it makes a web call to the Image URL and then pulls it. Further, it uses the below method of tweepy library to update Twitter status.

api.update_with_media(filename, status=message)

Now, if you have followed all these steps and call the get_random_image_from_nasa function, you should be able to tweet an image, but let's schedule it to run every one hour.

Here, we are using, schedule library, to run the above function every hour.

Congrats!, now your bot is working.

Let me know if you want me to write about how to host this bot to Heroku and run free for life. 🐶

Github Repo URL - https://github.com/a-blank-slate/mars-image-tweeting-bot/blob/main/tweet.py

Thanks! for reading this.

Copy data to Clipboard

If you want to copy an object or variable to the clipboard from the console, then use the below copy command. The below line will copy AABB text to the system clipboard.

copy("AABB");

Copy query param of page to Clipboard

const urlSearchParams = new URLSearchParams(window.location.search); const params = Object.fromEntries(urlSearchParams.entries()); copy(params['pageId']); Run this command in chrome console, after opening the specific page, this will copy the value of pageId param to the system clipboard

Couchbase

Scenario 1: Copy all documents from One Bucket to another

INSERT INTO `bucket-name` (KEY _k, VALUE _v) SELECT META().id _k, _v from `bucket-name` _v

Scenario 2: Deleting everything from bucket

DELETE FROM `bucket-name`

Git

Scenario 1: Need to remove a Modified File from Git pull request

Switch to the branch from which you created the pull request:

git checkout pull-request-branch

Overwrite the modified file(s) with the file in another branch, let's consider it's master:

git checkout origin/master -- src/main/java/HelloWorld.java

Commit and push it to the remote:

git commit -m "Removed a modified file from pull request" git push origin pull-request-branch

Scenario 2: Update the commit user name and email in the respective Git repo.

git config user.name user-name git config user.email username-git@gmail.com

Scenario 3: Git updating the buffer size in Git repo, helps in case a large file is present in Git and you are trying to clone it in the local system.

git config --global http.postBuffer 1048576000

Scenario 4: Stop tracking changes to a file in Sourcetree.

I guess This is the issue which troubled me most in git. Let's say, I have a file in my code base that I don't want to commit as this is specific to my local. But still, Sourcetree shows this file to me, every time I try to commit. This is really very annoying. to fix this run the below command in the repo folder and the Sourcetree will understand our feelings.

git update-index --assume-unchanged file.filename

For folder use this

git rm -r --cached path_to_your_folder/

To get undo/show dir's/files that are set to assume-unchanged run this:

git update-index --no-assume-unchanged file.filename

To get a list of dir's/files that are assume-unchanged run this:

git ls-files -v|grep '^h'

To delete all local checked out branches

git branch -D git branch

Maven

Scenario 1: Start the AEM in debug mode

java -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=127.0.0.1:8765 -XX:+HeapDumpOnOutOfMemoryError -XX:MaxPermSize=256M -Xmx1024m -Dorg.apache.sling.commons.log.level=INFO -jar cq-quickstart-6.5.0.jar

Scenario 2: Build and deploy AEM

mvn -PautoInstallPackage -Padobe-public clean install

Scenario 3: Start the Spring boot application

mvn clean spring-boot:run

Scenario 4: Start Spring boot in specific mode

mvn clean spring-boot:run -Dspring-boot.run.profiles=local

Scenario 5: Skip J-Unit test

-Dmaven.test.skip=true

Scenario 6: Start Spring boot in debug mode and also run a specific profile and skip j unit test compilation

mvn spring-boot:run -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005" -Dspring-boot.run.profiles=local -Dmaven.test.skip=true

Redis

Scenario 1: Start Redis Server

redis-server

Scenario 2: Clear redis cache

redis-cli flushall

To Be Continued....