Category Archives: Technology

Run short-codes from a custom field

Blog, PHP, Technology, Wordpress,

By default, WordPress treats the contents of custom fields as plain text and does not execute any shortcodes that may be included within them. This means that if you have a custom field containing a shortcode, such as `[shortcode] VALUE [/shortcode]`, the shortcode itself will not be processed, and the entire text, including the HTML tags, will be displayed as is.

To overcome this limitation and enable the execution of shortcodes within custom fields, you can use a code snippet in your template files. Here’s an elaboration of the process:

  1. Retrieve the custom field value: In your template file, you need to retrieve the value of the custom field using the appropriate WordPress function, such as `get_post_meta()` or `get_field()`, depending on whether you are using native custom fields or a plugin like Advanced Custom Fields.
  2. Process the content: Once you have obtained the custom field value, you can use the `do_shortcode()` function provided by WordPress to process and execute any shortcodes within the content. This function takes the custom field value as its parameter and returns the processed output.
  3. Display the processed content: Finally, you can echo or display the processed content on your website using the `echo` or `print` statements.

Here’s an example code snippet that demonstrates the process:


    $customFieldValue = get_post_meta(get_the_ID(), 'your_custom_field_name', true);
    $processedContent = do_shortcode($customFieldValue);
    echo $processedContent;

In the above code, `get_post_meta()` retrieves the value of the custom field with the specified name (`your_custom_field_name`), `do_shortcode()` processes the content, and `echo` displays the processed content on your website.

By using this snippet, you can run shortcodes from custom fields and have them executed properly, allowing you to incorporate dynamic functionality and display the desired output.

Methods to select an element by name in jQuery

Blog, jQuery, Technology

In jQuery, the attribute selector allows us to select elements based on their attributes. When it comes to selecting elements by their name attribute, there are a few methods available. Here’s a brief elaboration:

  1. Attribute Equals Selector: This method selects elements that have a specific name attribute value. It uses the syntax [name=’value’]. For example, if we want to select an input element with the name “username”, we can use the following code:

    jQuery('input[name="username"]')

  2. Attribute Contains Selector: This method selects elements that have a name attribute containing a specific value. It uses the syntax [name*=’value’]. For instance, if we want to select all input elements that have “email” in their name attribute, we can use the following code:

    jQuery('input[name*="email"]')

  3. Attribute Ends With Selector: This method selects elements that have a name attribute ending with a specific value. It uses the syntax [name$=’value’]. For instance, if we want to select input elements whose name attribute ends with “age”, we can use the following code:

    jQuery('input[name$="age"]')

  4. Attribute Starts With Selector: This method selects elements that have a name attribute starting with a specific value. It uses the syntax [name^=’value’]. For example, if we want to select input elements whose name attribute starts with “user”, we can use the following code:

    jQuery('input[name^="user"]')

These are just a few examples of how the attribute selector in jQuery can be used to select elements based on their name attribute. By combining these methods with other jQuery functions, you can perform various operations on the selected elements, such as manipulating their values or applying CSS styles.

Calculate fortnight date using PHP

PHP, Technology

The following code will calculate a recurring fortnightly date from a given date, i.e. a star-date using PHP. The date format should be ‘Y-m-d’ for the following code. However, you can make updates in it as per requirements.

For example: The start date for the fortnight cycle date was set to be as “2018-01-10”. Then, as per current cycle, next will be Start Date: 2018-01-10 | Next Date: 2023-05-23.


    <?php /* Fortnight Calculation in JavaScript */ function getFortNightString(sDate) { var param = []; var objDate = new Date(); param.todayDate = objDate.getFullYear() + '-' + ("0" + (objDate.getMonth() + 1)).slice(-2) + '-' + ("0" + (objDate.getDate())).slice(-2); param.todayDate = new Date(param.todayDate).getTime(); param.sDate = new Date(sDate).getTime(); param.timeDiff = Math.abs(param.todayDate - param.sDate); param.diffDays = Math.ceil(param.timeDiff / (1000 * 3600 * 24)); if (param.diffDays > 0 && param.sDate > param.todayDate) {
            param.diffDays = (14 + (param.diffDays % 14));
        } else {
            param.diffDays = (14 - (param.diffDays % 14));
        }

        param.dayCount = param.diffDays - 1;
        objDate.setDate(objDate.getDate() + param.dayCount);
        objDate = objDate.getFullYear() + '-' + ("0" + (objDate.getMonth() + 1)).slice(-2) + '-' + ("0" + (objDate.getDate())).slice(-2);
        return " Start Date: " + sDate + " | Next Date: " + objDate;
    }

    
    /* Fortnight Calculation in PHP */    
    $sDate = "2018-02-05";
    $sDate = date_create($sDate);
    $today = date_create(date("Y-m-d")); // or your date as well
    $dateDiff = date_diff($sDate, $today)->format("%a");

    if($dateDiff > 0 && $sDate > $today){
        $dateDiff = (14 + ($dateDiff % 14));
    }else{
        $dateDiff = (14 - ($dateDiff % 14));
    }

    $dateDiff--;
    echo date('Y-m-d', strtotime("$dateDiff day", strtotime(date('Y-m-d'))));

Send Mail from an AMP page

AMP, Technology, ,

In one of my projects I embedded Google’s new open-source initiative, AMP(Accelerated Mobil Pages). It was a WordPress website. I was all done with most of the part of website, however there was still a module which needs research i.e. implementing contact form into website.

While, we implementing any form in a website, we need to add validations as well as the data-handler scripts. So, I had two problems to resolve on:
1. I cannot use Javascript or jQuery for the validation. Although, I had HTML validation methods, but these are not enough. So, I needed some way to validate the form as good as we do with Javascript.
2. I had to send mail after the submission of form and redirect user to thank you page.

Thanks, to the AMP community on git-hub from where I get to know the various attributes we can use with `amp-form`. Basically, AMP provides many of event-handlers by using which you can implement the validations and in forms. You, can various event handlers on this git-hub library.

You can check amp-form attributes and there usage here.

You can send mail from your AMP page. Here is an example:

HTML of AMP form

<!doctype html>
<html amp lang="en">
  <head>
    <meta charset="utf-8">
    <script async src="https://cdn.ampproject.org/v0.js"></script>
    <title>Hello, AMPs</title>
    <link rel="canonical" href="http://example.ampproject.org/article-metadata.html" />
    <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">
    <script type="application/ld+json">
      {
        "@context": "http://schema.org",
        "@type": "NewsArticle",
        "headline": "Open-source framework for publishing content",
        "datePublished": "2015-10-07T12:02:41Z",
        "image": [
          "logo.jpg"
        ]
      }
    </script>
    <style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style><noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
    <script async custom-element="amp-form" src="https://cdn.ampproject.org/v0/amp-form-0.1.js"></script>
  </head>
  <body>
    <h1>Hello World!</h1>
      <form target="_top" action-xhr="https://test.php" method="post" name="test">
        <input type="text" name="name" value="ABRA KA DABRA!">
        <input type="submit"/>
    </form>
  </body>
</html>

PHP Code for Handling form request:

<?php
if(!empty($_POST))
{
    $name = $_POST['name'];

    /*/ this is the email we get from visitors*/
    $domain_url = (isset($_SERVER['HTTPS']) ? "https" : "http") . "://$_SERVER[HTTP_HOST]";
    $redirect_url = 'https://example.com/thank-you';

    /*//-->MUST BE 'https://';*/
    header("Content-type: application/json");
    header("Access-Control-Allow-Credentials: true");
    header("Access-Control-Allow-Origin: *.ampproject.org");
    header("AMP-Access-Control-Allow-Source-Origin: ".$domain_url);


    /*/ For Sending Error Use this code /*/
    if(!mail("[email protected]" , "Test submission" , "email: $name <br/> name: $name" , "From: $name\n ")){
        header("HTTP/1.0 412 Precondition Failed", true, 412);

        echo json_encode(array('errmsg'=>'There is some error while sending email!'));
        die();
    }
    else
    {
        /*/--Assuming all validations are good here--*/
        if( empty($redirect_url))
        {
            header("Access-Control-Expose-Headers: AMP-Access-Control-Allow-Source-Origin");
        }
        else
        {
            header("AMP-Redirect-To: ".$redirect_url);
            header("Access-Control-Expose-Headers: AMP-Redirect-To, AMP-Access-Control-Allow-Source-Origin");        }
            echo json_encode(array('successmsg'=>$_POST['name'].'My success message. [It will be displayed shortly(!) if with redirect]'));
        die();
    }
}?>

Design patterns for implementing directory structure in database

Database, Technology

Storing directories in a database is a common task in software development. One way to do this is to use a hierarchical database model, where each directory is represented as a node in a tree structure. In this model, directories are stored in a table with columns for the directory name, the parent directory ID (which references the parent directory’s row in the same table), and any other metadata associated with the directory.

When implementing this model, it is useful to use some design patterns to ensure that the directory structure is consistent and easy to manipulate. Here are some design patterns you can use when keeping directories in a database:

1. Composite Pattern: The Composite pattern is a design pattern that allows you to treat individual objects and compositions of objects in a uniform way. In the context of directory storage, this pattern can be used to represent directories as composite objects that can contain other directories or files. This makes it easy to navigate the directory structure and perform operations on directories at different levels of the hierarchy.

2. Visitor Pattern: The Visitor pattern is a design pattern that separates an algorithm from the objects it operates on. In the context of directory storage, this pattern can be used to define operations that can be performed on directories without having to modify the directory class itself. For example, you can define a visitor that deletes a directory and all its contents, or a visitor that prints out the directory structure in a formatted way.

3. Singleton Pattern: The Singleton pattern is a design pattern that ensures that there is only one instance of a class in the system. In the context of directory storage, this pattern can be used to ensure that there is only one instance of the directory tree in memory at any given time. This can help to reduce memory usage and ensure consistency across multiple parts of the system.

4. Factory Pattern: The Factory pattern is a design pattern that provides an interface for creating objects, but allows sub-classes to alter the type of objects that will be created. In the context of directory storage, this pattern can be used to create different types of directories (e.g., local directories, network directories, etc.) without having to modify the code that creates them.

5. Observer Pattern: The Observer pattern is a design pattern that allows objects to be notified of changes to other objects without having to check for changes explicitly. In the context of directory storage, this pattern can be used to notify other parts of the system when a directory has been created, deleted, or modified. This can help to ensure that all parts of the system are aware of changes to the directory structure, and can respond appropriately.

By using these design patterns, you can create a flexible and consistent directory storage system that can be easily manipulated and maintained.

What is OIS (Optical Image Stabilization)?

Mobile Devices, Technology

Optical Image Stabilization (OIS) is a mechanical technology designed to stabilize the camera lens while capturing photos or videos. It uses motors and gyroscopes to detect the movement of the camera and move the lens accordingly to counteract the motion, resulting in sharper and more stable images.

OIS technology is implemented by incorporating small movable lens elements into the camera lens. These lens elements are connected to a motor system that can move them in response to the camera’s movement, providing the necessary counteracting motion to stabilize the image. The motion sensors, typically gyroscopes or accelerometers, are also embedded into the camera body to detect and measure the camera’s movement.

When the camera is moved, the sensors detect the movement and send signals to the lens motor, which then moves the lens in the opposite direction to counteract the motion. The lens movement is calculated by the sensor in real-time, allowing the technology to compensate for even the smallest of camera movements.

OIS technology is especially useful in situations where the camera is held by hand, as even the slightest movement can cause image blur. In low light conditions or when using slow shutter speeds, OIS can help to reduce camera shake and produce sharper images. Additionally, OIS can improve the quality of videos by reducing the shakiness of the footage.

Compared to digital stabilization techniques that use software to process the image and reduce shake, OIS provides a more effective and natural solution as it physically moves the lens. While digital stabilization can introduce artifacts and distortions to the image, OIS produces more natural-looking images and videos.

In conclusion, OIS is a mechanical technology that uses motors and gyroscopes to detect and counteract the camera’s movement, resulting in sharper and more stable images. Its ability to stabilize the lens is especially useful in low light conditions or when capturing videos, as it reduces camera shake and produces more natural-looking footage.

What is AIS (Artificial Intelligence Stabilization)?

Mobile Devices, Technology

AIS (Artificial Intelligence Stabilization) is a technology that uses AI algorithms to stabilize images and videos captured by a camera. It is designed to address the camera shake and motion blur issues that can occur when shooting in low light or using long exposures.

Traditionally, image stabilization has been achieved using physical mechanisms such as gyroscopes and optical systems. However, these methods may be expensive, bulky, or may not provide sufficient stability in certain situations. With AIS, AI algorithms analyze camera motion and compensate for motion and shake for smooth, stable images.

AIS analyzes the images captured by the camera in real time and uses AI algorithms to predict and compensate for movement and shaking. This technology uses a combination of optical and digital stabilization techniques to achieve the best results. Optical stabilization involves the use of movable lens elements whose position can be adjusted to compensate for motion, while digital stabilization uses algorithms to crop and adjust the image to reduce camera shake.

One of the main advantages of the AIS is that the camera can capture long exposures and video in low light without the need for a tripod or other stabilization equipment. This is especially useful for photographers and videographers working in difficult conditions such as at night or in dim environment.

Another advantage of AIS is that it can improve the overall quality of images and videos by reducing noise and improving sharpness. By eliminating blur caused by camera shake, the final image will be sharper and more detailed, with better color accuracy and contrast.

Overall, AIS is a revolutionary technology that is changing the way images and videos are captured. By using AI algorithms to stabilize the camera and remove motion blur, photographers and videographers can achieve better results in challenging conditions and easily create stunning images and videos.