JSONP with example - Cross browser access

(allows you to make an HTTP request outside your own domain)

* JSONP  is a javascript 

* JSONP  is functions like ajax. 

* JSONP is a replacement for iframe 

* JSONP response page should return response data in json.

Eg : jsonp in javascript      

 request.html in one domain  (HTML/JS  file)

<script type="text/javascript">// <![CDATA[
            function callTheJsonp()
            {
                // the url of the script where we send the asynchronous call
                var url = "http://localhost/utils/jsonp/ajax.php?callback=parseRequest";
                // create a new script element
                var script = document.createElement('script');
                // set the src attribute to that url
                script.setAttribute('src', url);
                // insert the script in out page
                document.getElementsByTagName('head')[0].appendChild(script);
            }
            // this function should parse responses.. you can do anything you need..
            // you can make it general so it would parse all the responses the page receives based on a response field
            function parseRequest(response)
            {
                try // try to output this to the javascript console
                {
                    console.log(response);
                }
                catch(an_exception) // alert for the users that don't have a javascript console
                {
                    alert('product id ' + response.item_id + ': quantity = ' + response.quantity + ' & price = ' + response.price);
                }
            }
// ]]></script>
 <span onclick="callTheJsonp()">click here to make the jsonp call</span>




response.php in another domain:

 <?php
// get the callback function name
    $callback = '';
    if (isset($_GET['callback']))
    {
        $callback = filter_var($_GET['callback'], FILTER_SANITIZE_STRING);
    }
    // make an array with some random values.. so you would see that the results are fetched each time you call this script
    $array = array(
                    'item_id' => rand(1,13),
                    'price' => rand(14,17),
                    'quantity' => rand(18,30)
    );
    // output this array json encoded.. the callback function being the padding (a function available in the web page)
    echo $callback . '('.json_encode($array).');';

SITE TO REFER:

1. http://www.onlinesolutionsdevelopment.com/blog/web-development/javascript/jsonp-example/
2. http://www.ibm.com/developerworks/library/wa-aj-jsonp1/

How to sort a Map in Java

A full Java example to demonstrate how to sort a Map (HashMap) based on its values. The overall idea is, convert the Map into List, sort the List and put the sorted list back to a Map.

Map ---> List ---> Sort ---> Map

Map sorting example

 
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
public class SortMapExample{
 
   public static void main(String[] args) {
 
 System.out.println("Unsort Map......");
 Map<String,String> unsortMap = new HashMap<String,String>();
 unsortMap.put("1", "1");
 unsortMap.put("2", "A");
 unsortMap.put("3", "2");
 unsortMap.put("4", "B");
 unsortMap.put("5", "C");
 unsortMap.put("6", "c");
 unsortMap.put("7", "b");
 unsortMap.put("8", "a");
 
 Iterator iterator=unsortMap.entrySet().iterator();
 
        for (Map.Entry entry : unsortMap.entrySet()) {
         System.out.println("Key : " + entry.getKey() 
          + " Value : " + entry.getValue());
        }
 
        System.out.println("Sorted Map......");
        Map<String,String> sortedMap =  sortByComparator(unsortMap);
 
        for (Map.Entry entry : sortedMap.entrySet()) {
         System.out.println("Key : " + entry.getKey() 
          + " Value : " + entry.getValue());
        }
   }
 
   private static Map sortByComparator(Map unsortMap) {
 
        List list = new LinkedList(unsortMap.entrySet());
 
        //sort list based on comparator
        Collections.sort(list, new Comparator() {
             public int compare(Object o1, Object o2) {
            return ((Comparable) ((Map.Entry) (o1)).getValue())
            .compareTo(((Map.Entry) (o2)).getValue());
             }
 });
 
        //put sorted list into map again
 Map sortedMap = new LinkedHashMap();
 for (Iterator it = list.iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry)it.next();
      sortedMap.put(entry.getKey(), entry.getValue());
 }
 return sortedMap;
   } 
}

Result

Unsort Map......
Key : 3 Value : 2
Key : 2 Value : A
Key : 1 Value : 1
Key : 7 Value : b
Key : 6 Value : c
Key : 5 Value : C
Key : 4 Value : B
Key : 8 Value : a
Sorted Map......
Key : 1 Value : 1
Key : 3 Value : 2
Key : 2 Value : A
Key : 4 Value : B
Key : 5 Value : C
Key : 8 Value : a
Key : 7 Value : b
Key : 6 Value : c

Unaccent letters

Using String.replaceAll() 

The following snippets remove from a String accented letters and replace them by their regular ASCII equivalent.These can be useful before inserting data into a database to made sorting easier.

Using java.text.Normalizer

It's a simple using the java.text.Normalizer class.We are calling the normalize(). If we pass à, the method returns a + ` . Then using a regular expression, we clean up the string to keep only valid US-ASCII characters.

import java.text.Normalizer;
import java.util.regex.Pattern;

public class StringUtils {
  private StringUtils() {}

  public static String unAccent(String s) {
      //
      // JDK1.5
      //   use sun.text.Normalizer.normalize(s, Normalizer.DECOMP, 0);
      //
      String temp = Normalizer.normalize(s, Normalizer.Form.NFD);
      Pattern pattern = Pattern.compile("\\p{InCombiningDiacriticalMarks}+");
      return pattern.matcher(temp).replaceAll("");
  }

  public static void main(String args[]) throws Exception{
      String value = "é à î _ @";
      System.out.println(StringUtils.unAccent(value));
      // output : e a i _ @
  }
}

 

Using String.replaceAll()

As an alternative, replaceAll() and regular expressions on a String can also be used :

public class Test {
  public static void main(String args[]) {
    String s = "È,É,Ê,Ë,Û,Ù,Ï,Î,À,Â,Ô,è,é,ê,ë,û,ù,ï,î,à,â,ô";

    s = s.replaceAll("[èéêë]","e");
    s = s.replaceAll("[ûù]","u");
    s = s.replaceAll("[ïî]","i");
    s = s.replaceAll("[àâ]","a");
    s = s.replaceAll("Ô","o");

    s = s.replaceAll("[ÈÉÊË]","E");
    s = s.replaceAll("[ÛÙ]","U");
    s = s.replaceAll("[ÏÎ]","I");
    s = s.replaceAll("[ÀÂ]","A");
    s = s.replaceAll("Ô","O");

    System.out.println(s);
    // output : E,E,E,E,U,U,I,I,A,A,O,e,e,e,e,u,u,i,i,a,a,o
    }
}

The String.indexOf()

While the two techniques above are ok... there are a little bit slow.The following HowTo is faster because we using one String to contain all the possible characters to be converted and a String with the ASCII equivalent. So we need to detect the position in the first String and then do a lookup in the second String.

public class AsciiUtils {
    private static final String PLAIN_ASCII =
      "AaEeIiOoUu"    // grave
    + "AaEeIiOoUuYy"  // acute
    + "AaEeIiOoUuYy"  // circumflex
    + "AaOoNn"        // tilde
    + "AaEeIiOoUuYy"  // umlaut
    + "Aa"            // ring
    + "Cc"            // cedilla
    + "OoUu"          // double acute
    ;

    private static final String UNICODE =
     "\u00C0\u00E0\u00C8\u00E8\u00CC\u00EC\u00D2\u00F2\u00D9\u00F9"
    + "\u00C1\u00E1\u00C9\u00E9\u00CD\u00ED\u00D3\u00F3\u00DA\u00FA\u00DD\u00FD"
    + "\u00C2\u00E2\u00CA\u00EA\u00CE\u00EE\u00D4\u00F4\u00DB\u00FB\u0176\u0177"
    + "\u00C3\u00E3\u00D5\u00F5\u00D1\u00F1"
    + "\u00C4\u00E4\u00CB\u00EB\u00CF\u00EF\u00D6\u00F6\u00DC\u00FC\u0178\u00FF"
    + "\u00C5\u00E5"
    + "\u00C7\u00E7"
    + "\u0150\u0151\u0170\u0171"
    ;

    // private constructor, can't be instanciated!
    private AsciiUtils() { }

    // remove accentued from a string and replace with ascii equivalent
    public static String convertNonAscii(String s) {
       if (s == null) return null;
       StringBuilder sb = new StringBuilder();
       int n = s.length();
       for (int i = 0; i < n; i++) {
          char c = s.charAt(i);
          int pos = UNICODE.indexOf(c);
          if (pos > -1){
              sb.append(PLAIN_ASCII.charAt(pos));
          }
          else {
              sb.append(c);
          }
       }
       return sb.toString();
    }

    public static void main(String args[]) {
       String s =
         "The result : È,É,Ê,Ë,Û,Ù,Ï,Î,À,Â,Ô,è,é,ê,ë,û,ù,ï,î,à,â,ô,ç";
       System.out.println(AsciiUtils.convertNonAscii(s));
       // output :
       // The result : E,E,E,E,U,U,I,I,A,A,O,e,e,e,e,u,u,i,i,a,a,o,c
    }
}

 

As a bonus, here a method to convert a given string to uppercase with no accent. This can be useful in a database field to simplify name searching with accent or not.

public class StringUtils {
  private StringUtils() {}

  private static final String UPPERCASE_ASCII =
    "AEIOU" // grave
    + "AEIOUY" // acute
    + "AEIOUY" // circumflex
    + "AON" // tilde
    + "AEIOUY" // umlaut
    + "A" // ring
    + "C" // cedilla
    + "OU" // double acute
    ;

  private static final String UPPERCASE_UNICODE =
    "\u00C0\u00C8\u00CC\u00D2\u00D9"
    + "\u00C1\u00C9\u00CD\u00D3\u00DA\u00DD"
    + "\u00C2\u00CA\u00CE\u00D4\u00DB\u0176"
    + "\u00C3\u00D5\u00D1"
    + "\u00C4\u00CB\u00CF\u00D6\u00DC\u0178"
    + "\u00C5"
    + "\u00C7"
    + "\u0150\u0170"
    ;

  public static String toUpperCaseSansAccent(String txt) {
       if (txt == null) {
          return null;
       }
       String txtUpper = txt.toUpperCase();
       StringBuilder sb = new StringBuilder();
       int n = txtUpper.length();
       for (int i = 0; i < n; i++) {
          char c = txtUpper.charAt(i);
          int pos = UPPERCASE_UNICODE.indexOf(c);
          if (pos > -1){
            sb.append(UPPERCASE_ASCII.charAt(pos));
          }
          else {
            sb.append(c);
          }
       }
       return sb.toString();
  }


  public static void main(String args[]) throws Exception {
    String s =
      "The result : È,É,Ê,Ë,Û,Ù,Ï,Î,À,Â,Ô,è,é,ê,ë,û,ù,ï,î,à,â,ô,ç";
    System.out.println(
         StringUtils.toUpperCaseSansAccent(s));
    // output :
    //  THE RESULT : E,E,E,E,U,U,I,I,A,A,O,E,E,E,E,U,U,I,I,A,A,O,C
  }
}

 

Time Ago - to calculate the time difference between two times in java and php

Java program:
------------------------


import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.concurrent.TimeUnit;
import java.math.*;

public class TimeAgo {

    public String TimeAgo(long dateFrom, long dateTo) {

        Calendar now = Calendar.getInstance();
        if (dateFrom <= 0) {
            return "A long time ago";
        }
        // if(dateTo == -1) { dateTo = now.getTimeInMillis(); }

        long difference = dateTo - dateFrom;

        char interval = 0;
        float months_difference;
        String res = "";
        long datediff = 0;

        // If difference is less than 60 seconds,
        // seconds is a good interval of choice

        if (difference < 60) {
            interval = 's';
        }

        // If difference is between 60 seconds and
        // 60 minutes, minutes is a good interval
        else if (difference >= 60 && difference < 60 * 60) {
            interval = 'n';
        }

        // If difference is between 1 hour and 24 hours
        // hours is a good interval
        else if (difference >= 60 * 60 && difference < 60 * 60 * 24) {
            interval = 'h';
        }

        // If difference is between 1 day and 7 days
        // days is a good interval
        else if (difference >= 60 * 60 * 24 && difference < 60 * 60 * 24 * 7) {
            interval = 'd';
        }

        // If difference is between 1 week and 30 days
        // weeks is a good interval
        else if (difference >= 60 * 60 * 24 * 7
                && difference < 60 * 60 * 24 * 30) {
            interval = 'w';
        }

        // If difference is between 30 days and 365 days
        // months is a good interval, again, the same thing
        // applies, if the 29th February happens to exist
        // between your 2 dates, the function will return
        // the 'incorrect' value for a day
        else if (difference >= 60 * 60 * 24 * 30
                && difference < 60 * 60 * 24 * 365) {
            interval = 'm';
        }

        // If difference is greater than or equal to 365
        // days, return year. This will be incorrect if
        // for example, you call the function on the 28th April
        // 2008 passing in 29th April 2007. It will return
        // 1 year ago when in actual fact (yawn!) not quite
        // a year has gone by
        else if (difference >= 60 * 60 * 24 * 365) {
            interval = 'y';
        }

        // Based on the interval, determine the
        // number of units between the two dates
        // From this point on, you would be hard
        // pushed telling the difference between
        // this function and DateDiff. If the $datediff
        // returned is 1, be sure to return the singular
        // of the unit, e.g. 'day' rather 'days'

        switch (interval) {
        case 'm':

            try {

                dateFrom = dateFrom * 1000;

                dateTo = dateTo * 1000;

                months_difference = (float) Math.floor(difference / 60 / 60
                        / 24 / 29);

                SimpleDateFormat sdf = new SimpleDateFormat(
                        "yyyy-MM-dd-HH-mm-ss");

                Date resultdate1 = new Date(dateFrom);

                String fullDate1 = sdf.format(resultdate1);
               
                String date_split1[] = fullDate1.split("-");
                int y1 = Integer.parseInt(date_split1[0]);
                int mon1 = Integer.parseInt(date_split1[1]);
                int d1 = Integer.parseInt(date_split1[2]);
                int h1 = Integer.parseInt(date_split1[3]);
                int min1 = Integer.parseInt(date_split1[4]);
                int s1 = Integer.parseInt(date_split1[5]);

                Date resultdate2 = new Date(dateTo);

                String fullDate2 = sdf.format(resultdate2);
               
                String[] date_split2 = fullDate2.split("-");

                int y2 = Integer.parseInt(date_split2[0]);
                int mon2 = Integer.parseInt(date_split2[1]);
                int d2 = Integer.parseInt(date_split2[2]);
                int h2 = Integer.parseInt(date_split2[3]);
                int min2 = Integer.parseInt(date_split2[4]);
                int s2 = Integer.parseInt(date_split2[5]);

                Calendar calendar = Calendar.getInstance();

                calendar.set(Calendar.HOUR, h1);
                calendar.set(Calendar.MINUTE, min1);
                calendar.set(Calendar.SECOND, s1);
                int add_month = (int) (mon1 + months_difference);
                calendar.set(Calendar.MONTH, add_month);
                calendar.set(Calendar.DAY_OF_MONTH, d2);
                calendar.set(Calendar.YEAR, y1);

               
                long milli = calendar.getTimeInMillis() / 1000;

                dateTo = dateTo / 1000;
               
                while (milli < dateTo) {
                    months_difference++;
                }
                datediff = (int) months_difference;

                // We need this in here because it is possible
                // to have an 'm' interval and a months
                // difference of 12 because we are using 29 days
                // in a month

                if (datediff == 12) {
                    datediff--;
                }

                res = (datediff == 1) ? +datediff + " month ago" : +datediff
                        + "months ago";
            } catch (Exception e) {
                e.printStackTrace();
            }
            break;

        case 'y':
            datediff = (int) Math.floor(difference / 60 / 60 / 24 / 365);
            res = (datediff == 1) ? +datediff + " year ago" : +datediff
                    + " years ago";
            break;

        case 'd':
            datediff = (int) Math.floor(difference / 60 / 60 / 24);
            res = (datediff == 1) ? +datediff + " day ago" : +datediff
                    + "days ago";
            break;

        case 'w':
            datediff = (int) Math.floor(difference / 60 / 60 / 24 / 7);
            res = (datediff == 1) ? +datediff + " week ago" : +datediff
                    + " weeks ago";
            break;

        case 'h':
            datediff = (int) Math.floor(difference / 60 / 60);
            res = (datediff == 1) ? +datediff + " hour ago" : +datediff
                    + " hours ago";
            break;

        case 'n':
            datediff = (int) Math.floor(difference / 60);
            res = (datediff == 1) ? +datediff + " minute ago" : +datediff
                    + " minutes ago";
            break;

        case 's':
            datediff = difference;
            if (datediff < 1) {
                res = "few seconds ago";
            } else {
                res = (datediff == 1) ? +datediff + " second ago" : +datediff
                        + " seconds ago";
            }
            break;
        }
        return res;
    }

    public static void main(String args[]) {
        // TimeAgo ta = new TimeAgo(1294406525,1326288125);
        TimeAgo ta = new TimeAgo();
        String res = ta.TimeAgo(1299583838235L / 1000, 1326349418235L / 1000);
        System.out.println(res);
    }

}



Php :
------
<?php

function TimeAgo($datefrom,$dateto=-1)
{
// Defaults and assume if 0 is passed in that
// its an error rather than the epoch

if($datefrom<=0) { return "A long time ago"; }
if($dateto==-1) { $dateto = time(); }

// Calculate the difference in seconds betweeen
// the two timestamps

$difference = $dateto - $datefrom;

// If difference is less than 60 seconds,
// seconds is a good interval of choice

if($difference < 60)
{
$interval = "s";
}

// If difference is between 60 seconds and
// 60 minutes, minutes is a good interval
elseif($difference >= 60 && $difference<60*60)
{
$interval = "n";
}

// If difference is between 1 hour and 24 hours
// hours is a good interval
elseif($difference >= 60*60 && $difference<60*60*24)
{
$interval = "h";
}

// If difference is between 1 day and 7 days
// days is a good interval
elseif($difference >= 60*60*24 && $difference<60*60*24*7)
{
$interval = "d";
}

// If difference is between 1 week and 30 days
// weeks is a good interval
elseif($difference >= 60*60*24*7 && $difference <
60*60*24*30)
{
$interval = "ww";
}

// If difference is between 30 days and 365 days
// months is a good interval, again, the same thing
// applies, if the 29th February happens to exist
// between your 2 dates, the function will return
// the 'incorrect' value for a day
elseif($difference >= 60*60*24*30 && $difference <
60*60*24*365)
{
$interval = "m";
}

// If difference is greater than or equal to 365
// days, return year. This will be incorrect if
// for example, you call the function on the 28th April
// 2008 passing in 29th April 2007. It will return
// 1 year ago when in actual fact (yawn!) not quite
// a year has gone by
elseif($difference >= 60*60*24*365)
{
$interval = "y";
}

// Based on the interval, determine the
// number of units between the two dates
// From this point on, you would be hard
// pushed telling the difference between
// this function and DateDiff. If the $datediff
// returned is 1, be sure to return the singular
// of the unit, e.g. 'day' rather 'days'

switch($interval)
{
case "m":
$months_difference = floor($difference / 60 / 60 / 24 /29);

$d =  mktime(date("H", $datefrom), date("i", $datefrom),date("s", $datefrom), date("n", $datefrom)+($months_difference),date("j", $dateto), date("Y", $datefrom)) ;
echo $d;
echo "</br>";
while (mktime(date("H", $datefrom), date("i", $datefrom),date("s", $datefrom), date("n", $datefrom)+($months_difference),date("j", $dateto), date("Y", $datefrom)) < $dateto)
{
   
$months_difference++;
}
$datediff = $months_difference;

// We need this in here because it is possible
// to have an 'm' interval and a months
// difference of 12 because we are using 29 days
// in a month

if($datediff==12)
{
$datediff--;
}

$res = ($datediff==1) ? "$datediff month ago" : "$datediff
months ago";
break;

case "y":
$datediff = floor($difference / 60 / 60 / 24 / 365);
$res = ($datediff==1) ? "$datediff year ago" : "$datediff
years ago";
break;

case "d":
$datediff = floor($difference / 60 / 60 / 24);
$res = ($datediff==1) ? "$datediff day ago" : "$datediff
days ago";
break;

case "ww":
$datediff = floor($difference / 60 / 60 / 24 / 7);
$res = ($datediff==1) ? "$datediff week ago" : "$datediff
weeks ago";
break;

case "h":
$datediff = floor($difference / 60 / 60);
$res = ($datediff==1) ? "$datediff hour ago" : "$datediff
hours ago";
break;

case "n":
$datediff = floor($difference / 60);
$res = ($datediff==1) ? "$datediff minute ago" :
"$datediff minutes ago";
break;

case "s":
$datediff = $difference;
 if($datediff<1){
        $res = "few seconds ago";
    }
    else{
       $res = ($datediff==1) ? "$datediff second ago" :
"$datediff seconds ago";
    }
break;
}
return $res;
}


$age = TimeAgo(1323583838, 1326349418);

echo $age;

?>








pass two timestamp in TimeAgo methods and get their difference in seconds month , day ,week , hour , year basis........