source: other-projects/maori-lang-detection/src/org/greenstone/atea/Utility.java@ 33810

package org.greenstone.atea;

import java.io.*;
import java.net.InetAddress;
import java.util.zip.GZIPInputStream;

import com.maxmind.geoip.*; // for LookupService and Location

import org.apache.log4j.Logger;

public class Utility {
    private static Logger logger = Logger.getLogger(org.greenstone.atea.Utility.class.getName());
    
    // Run gunzip
    // To avoid making this linux specific, use Java to unzip, instead of running gunzip as process
    // https://www.mkyong.com/java/how-to-decompress-file-from-gzip-file/
    public static boolean unzipFile(File inZipFile, File outFile) { 
    
    byte[] buffer = new byte[1024];

    // try-with-resources will safely close streams/dispose resources on success or error and exceptions
    try (       
        GZIPInputStream gzis = new GZIPInputStream(new FileInputStream(inZipFile));     
        FileOutputStream out = new FileOutputStream(outFile);
    ) {
        int len;
        while ((len = gzis.read(buffer)) > 0) {
            out.write(buffer, 0, len);
        }
        
        //gzis.close();
        //out.close();
        
        logger.debug("Unzipped " + inZipFile + " to " + outFile);
        
    } catch(IOException ex) {
        //error("Failed to unzip " + inZipFile);
        System.err.println("Failed to unzip " + inZipFile);
        ex.printStackTrace();
        return false;
    }

    return true;
    }

    /**
     * Attribution following below is as per https://dev.maxmind.com/geoip/geoip2/geolite2/
     *
     * This product includes GeoLite2 data created by MaxMind, available from
     * <a href="https://www.maxmind.com">https://www.maxmind.com</a>.
     *
     * Usage:
     * https://stackoverflow.com/questions/1415851/best-way-to-get-geo-location-in-java
     * version I'm using: https://github.com/maxmind/geoip-api-java
     * Newer version: https://maxmind.github.io/GeoIP2-java/
     *
     * @return 2 letter countrycode in uppercase or an exception
     */
    public static String getCountryCodeOfDomain(String domainWithProtocol, File geoLiteCityDatFile)
    throws Exception
    {   
    //int startIndex = domainWithProtocol.indexOf("//"); // http:// or https:// prefix
    //startIndex = (startIndex == -1) ? 0 : (startIndex+2); // skip past the protocol's // portion
    String domain = stripProtocolFromURL(domainWithProtocol); //domainWithProtocol.substring(startIndex);   
    
    // pass in the GeoLiteCity.dat file to be able to do the location lookup for domain's IP
    LookupService cl = new LookupService(geoLiteCityDatFile, LookupService.GEOIP_MEMORY_CACHE);
        
    // get IP for domain
    InetAddress inetAddress = InetAddress.getByName(domain);
    String ipAddress = inetAddress.getHostAddress();
    
    // get location object for IP
    Location location = cl.getLocation(ipAddress);
    
    if(location == null) {
        throw new Exception("@@@@ No location info in DB for: " + domain);
    } else {
        return location.countryCode;
    }
    
    }
    
    public static String stripProtocolAndWWWFromURL(String url) {
    url = stripProtocolFromURL(url);
    
    if(url.startsWith("www.")) { // strip any "wwww." at start as well too
        url = url.substring(4);
    }
    
    return url;
    }
    
    public static String stripProtocolFromURL(String url) {
    int startIndex = url.indexOf("//"); // for http:// or https:// prefix
    startIndex = (startIndex == -1) ? 0 : (startIndex+2); // skip past the protocol's // portion
    return url.substring(startIndex);
    }
    
    
    /** Work out the 'domain' for a given url.
     * This retains any www. or subdomain prefix.
     */
    public static String getDomainForURL(String url, boolean withProtocol) {
    int startIndex = startIndex = url.indexOf("//"); // for http:// or https:// prefix
    startIndex = (startIndex == -1) ? 0 : (startIndex+2); // skip past the protocol's // portion
    // keep the protocol around in case param withProtocol=true
    String protocol = (startIndex == -1) ? "" : url.substring(0, startIndex);
    
    String domain = url.substring(startIndex);
    int endIndex = domain.indexOf("/");
    if(endIndex == -1) endIndex = domain.length();
    domain = domain.substring(0, endIndex);

    if(withProtocol) {
        // now that we have the domain (everything to the first / when there is no protocol)
        // can glue the protocol back on
        domain = protocol + domain;
    }
    
    return domain;
    }
    
    public static boolean isDomainInCountry(String domainWithProtocol,
                        String countryCode, File geoLiteCityDatFile)
    {
    countryCode = countryCode.toUpperCase();
    
    int startIndex = domainWithProtocol.indexOf("//"); // http:// or https:// prefix
    startIndex = (startIndex == -1) ? 0 : (startIndex+2); // skip past the protocol's // portion
    String domain = domainWithProtocol.substring(startIndex);   
    
    boolean result = false;
    try {
        // pass in the GeoLiteCity.dat file to be able to do the location lookup for domain's IP
        LookupService cl = new LookupService(geoLiteCityDatFile, LookupService.GEOIP_MEMORY_CACHE);
        
        // get IP for domain
        InetAddress inetAddress = InetAddress.getByName(domain);
        String ipAddress = inetAddress.getHostAddress();
        
        // get location object for IP
        Location location = cl.getLocation(ipAddress);

        if(location != null) {
        // compare country code with tld parameter
        System.err.println("@@@@ Got country code: " + location.countryCode);
        result = location.countryCode.equals(countryCode);
        } else {
        System.err.println("@@@@ No location info in DB for: " + domainWithProtocol);
        }
    } catch(Exception e) {
        e.printStackTrace();
        System.err.println("Could not check if domain " + domain + " was in country: " + countryCode);
    } finally {
        return result;
    }
    }
}