Hi ,
I am getting 401 Http Code . Please help.
Here is my code . I have replaced apikey and secretCode and Aid to “—” for privacy

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class OMGTest2 {

/** String for signature data */
private String mSigData;

/** Default encoding. */
private static final String DEFAULT_ENCODING = “UTF-8”;

/** Index of a component which was not found. */
private final static int NOT_FOUND = -1;

/** String used for encoding special characters */
private static final String ALLOWED_URI_CHARS = “@#&=*+-_.,:!?()/~’%”;

/**Please add your Api key here*/
private String mApiKey = “——“;

/**Please add your private key here*/
private String apiSecret = “—-“;
//http://api.omgpm.com/network/OMGNetworkApi.svc/v1.2/ProductFeeds/GetMerchants?Key={Key}&Sig={Signature}&SigData={SignatureData}&AID={AID}&AgencyID={AgencyID}&output={xml or json}

/** Base url **/
private String BASE_URL = “http://api.omgpm.com/network/OMGNetworkApi.svc/v1.2/ProductFeeds/GetMerchants?AgencyID=95&aid=—–“;
public static void main(String[] args) {
OMGTest2 sample = new OMGTest2();
try {
sample.loadAccounts();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* Method to load Account Details
*
*/
private void loadAccounts() {
String url = generateUrl();
sendGet(url);
}

/**
* Method to generate Url
*
* @return
*/
private String generateUrl() {
String url = “”;
try {
url = BASE_URL
+ “&Key=”
+ mApiKey
+ “&Sig=”
+ URLEncoder.encode(md5(apiSecret.concat(getSigData())),
“UTF-8”) + “&SigData=”
+ encode(mSigData, ALLOWED_URI_CHARS) + “&output=xml”;
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(“Generated Url ” + url);
return url;
}

/** HTTP GET request */
private void sendGet(String url) {

try {
URL obj = new URL(url);
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod(“GET”);
con.setRequestProperty(“Content-Type”, “application/json”);
con.connect();

int responseCode = con.getResponseCode();
System.out.println(“Response Code : ” + responseCode);

BufferedReader in = new BufferedReader(new InputStreamReader(
con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();

while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();

// print result
System.out.println(response.toString());
} catch (Exception ex) {
ex.printStackTrace();
}
}

/**
* Used to generate md5 hashed value
*
* @param s
* @return
*/
private String md5(final String s) {
final String MD5 = “MD5”;
try {
// Create MD5 Hash
MessageDigest digest = java.security.MessageDigest.getInstance(MD5);
digest.update(s.getBytes());
byte messageDigest[] = digest.digest();

// Create Hex String
StringBuilder hexString = new StringBuilder();
for (byte aMessageDigest : messageDigest) {
String hash = Integer.toHexString(0xFF & aMessageDigest);
while (hash.length() < 2)
hash = "0" + hash;
hexString.append(hash);
}
return hexString.toString();

} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return "";
}

/**
* Method to generate signature data
*/
private String getSigData() {
Calendar c = Calendar.getInstance();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
mSigData = df.format(c.getTime());
return mSigData;
}

private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();

/**
* Encodes characters in the given string as '%'-escaped octets using the
* UTF-8 scheme. Leaves letters ("A-Z", "a-z"), numbers ("0-9"), and
* unreserved characters ("_-!.~'()*") intact. Encodes all other characters
* with the exception of those specified in the allow argument.
*
* @param s
* string to encode
* @param allow
* set of additional characters to allow in the encoded form,
* null if no characters should be skipped
* @return an encoded version of s suitable for use as a URI component, or
* null if s is null
*/
public static String encode(String s, String allow) {
if (s == null) {
return null;
}

// Lazily-initialized buffers.
StringBuilder encoded = null;

int oldLength = s.length();

// This loop alternates between copying over allowed characters and
// encoding in chunks. This results in fewer method calls and
// allocations than encoding one character at a time.
int current = 0;
while (current < oldLength) {
// Start in "copying" mode where we copy over allowed chars.

// Find the next character which needs to be encoded.
int nextToEncode = current;
while (nextToEncode current) {
// Append allowed characters leading up to this point.
encoded.append(s, current, nextToEncode);
} else {
// assert nextToEncode == current
}

// Switch to “encoding” mode.

// Find the next allowed character.
current = nextToEncode;
int nextAllowed = current + 1;
while (nextAllowed < oldLength
&& !isAllowed(s.charAt(nextAllowed), allow)) {
nextAllowed++;
}

// Convert the substring to bytes and encode the bytes as
// '%'-escaped octets.
String toEncode = s.substring(current, nextAllowed);
try {
byte[] bytes = toEncode.getBytes(DEFAULT_ENCODING);
int bytesLength = bytes.length;
for (int i = 0; i > 4]);
encoded.append(HEX_DIGITS[bytes[i] & 0xf]);
}
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}

current = nextAllowed;
}

// Encoded could still be null at this point if s is empty.
return encoded == null ? s : encoded.toString();
}

/**
* Returns true if the given character is allowed.
*
* @param c
* character to check
* @param allow
* characters to allow
* @return true if the character is allowed or false if it should be encoded
*/
private static boolean isAllowed(char c, String allow) {
return (c >= ‘A’ && c = ‘a’ && c = ‘0’ && c <= '9')
|| "_-!.~'()*".indexOf(c) != NOT_FOUND
|| (allow != null && allow.indexOf(c) != NOT_FOUND);
}
}