public String toXMLString(java.util.HashMap domMap) {
StringBuffer sb = new StringBuffer();
sb.append("<class type=\"" + this.getClass().getName() + "\" ");
sb.append(" id=\"" + this.getId() + "\"");
sb.append(
" source=\"" + ims.configuration.EnvironmentConfig.getImportExportSourceName() + "\" ");
sb.append(" classVersion=\"" + this.getClassVersion() + "\" ");
sb.append(" component=\"" + this.getIsComponentClass() + "\" >");
if (domMap.get(this) == null) {
domMap.put(this, this);
sb.append(this.fieldsToXMLString(domMap));
}
sb.append("</class>");
String keyClassName = "Summary";
String externalSource = ims.configuration.EnvironmentConfig.getImportExportSourceName();
ims.configuration.ImportedObject impObj =
(ims.configuration.ImportedObject)
domMap.get(keyClassName + "_" + externalSource + "_" + this.getId());
if (impObj == null) {
impObj = new ims.configuration.ImportedObject();
impObj.setExternalId(this.getId());
impObj.setExternalSource(externalSource);
impObj.setDomainObject(this);
impObj.setLocalId(this.getId());
impObj.setClassName(keyClassName);
domMap.put(keyClassName + "_" + externalSource + "_" + this.getId(), impObj);
}
return sb.toString();
}
/**
* Load Default FontStylesCollection, singleton 1) if no citation style is given, return default
* {@link FontStylesCollection} 2) if citation style is given, check citation style directory. If
* there is a citation style specific {@link FontStylesCollection} in the citation style directory
* FontStylesCollection, get it; if not - get default FontStylesCollection
*
* @param cs - citation style
* @return {@link FontStylesCollection}
* @throws CitationStyleManagerException
*/
public static FontStylesCollection loadFontStylesCollection(String cs) {
// get default FontStyleCollection from __Default__ element for empty cs
if (cs == null || "".equals(cs.trim())) return loadFontStylesCollection("__Default__");
if (fsc.containsKey(cs)) return fsc.get(cs);
try {
// load __Default__ collection
if ("__Default__".equalsIgnoreCase(cs)) {
fsc.put(
cs,
FontStylesCollection.loadFromXml(
CitationUtil.getPathToCitationStyles() + FONT_STYLES_COLLECTION_FILE));
} else {
InputStream inputStream =
ResourceUtil.getResourceAsStream(
CitationUtil.getPathToCitationStyle(cs) + FONT_STYLES_COLLECTION_FILE,
XmlHelper.class.getClassLoader());
// get specific FontStyleCollection for citation style if exists
if (inputStream != null) {
fsc.put(cs, FontStylesCollection.loadFromXml(inputStream));
}
// otherwise: get __Default_ one
else {
fsc.put(cs, loadFontStylesCollection());
}
}
return fsc.get(cs);
} catch (Exception e) {
// TODO Auto-generated catch block
throw new RuntimeException("Cannot loadFontStylesCollection: ", e);
}
}
public int totalMatches(String[] ngrams) {
ArrayList<int[]> list = new ArrayList<int[]>(); // list to change letters into numbers
HashMap calc = new HashMap(); // map to calculate sum of Cn2
for (int i = 0; i < ngrams.length; i++) {
int[] nowInts = stringToInts(ngrams[i]);
list.add(nowInts); // loop every string,change into int[],store in arraylist
}
for (int j = 0; j < list.size() - 1; j++) {
int[] first = list.get(j);
calc.put(first, 1); // this one must be different from previous ones
for (int k = j + 1; k < list.size(); k++) {
int[] second = list.get(k);
if (check(first, second)) {
int p = calc.get(first).hashCode();
calc.replace(first, p, p + 1); // increment of counting in the same int[]
list.remove(second);
k--;
// list is shorted by removal,k should stay at the same position for next test
}
if (k == list.size() - 1 && check(first, second) == false) {
calc.put(second, 1); // if the last one is not the same as last-1,set it as 1
}
}
}
int totalMatches = calculation(calc);
return totalMatches;
}
/** @param getFailureId */
public void alarmStat(String getFailureId, boolean callBackFlag) {
String failureId = null;
String loseMailId = null;
for (String tempId : getFailureId.split(",+")) {
if (hashMap.containsKey(tempId)) {
if (hashMap.get(tempId) + 1 >= Integer.parseInt(SenderConfig.getProp("sendFailureTimes"))) {
loseMailId = loseMailId == null ? tempId : loseMailId + "," + tempId;
hashMap.remove(tempId);
if (callBackFlag) {
FailureNotifier.notifier(tempId);
log.error("[lose mailID]" + " [" + tempId + "]");
}
} else {
failureId = failureId == null ? tempId : failureId + "," + tempId;
hashMap.put(tempId, hashMap.get(tempId) + 1);
}
} else {
failureId = failureId == null ? tempId : failureId + "," + tempId;
hashMap.put(tempId, 1);
}
}
if (failureId != null && callBackFlag) {
log.info("[wait for sending again]" + " [" + failureId + "]");
callBack(failureId);
}
if (loseMailId != null) {
alarm(loseMailId);
}
}
/**
* A method to build four coordinates representing a bounding box given a start coordinate and a
* distance
*
* @param latitude a latitude coordinate in decimal notation
* @param longitude a longitude coordinate in decimal notation
* @param distance the distance to add in metres
* @return a hashMap representing the bounding box (NE,SE,SW,NW)
*/
public static java.util.HashMap<String, Coordinate> getBoundingBox(
float latitude, float longitude, int distance) {
// check on the parameters
if (isValidLatitude(latitude) == false
|| isValidLongitude(longitude) == false
|| distance <= 0) {
throw new IllegalArgumentException("All parameters are required and must be valid");
}
// convert the distance from metres to kilometers
float kilometers = distance / 1000;
// declare helper variables
java.util.HashMap<String, Coordinate> boundingBox = new java.util.HashMap<String, Coordinate>();
// calculate the coordinates
Coordinate north = addDistanceNorth(latitude, longitude, distance);
Coordinate south = addDistanceSouth(latitude, longitude, distance);
Coordinate east = addDistanceEast(latitude, longitude, distance);
Coordinate west = addDistanceWest(latitude, longitude, distance);
// build the bounding box object
boundingBox.put("NE", new Coordinate(north.getLatitude(), east.getLongitude()));
boundingBox.put("SE", new Coordinate(south.getLatitude(), east.getLongitude()));
boundingBox.put("SW", new Coordinate(south.getLatitude(), west.getLongitude()));
boundingBox.put("NW", new Coordinate(north.getLatitude(), west.getLongitude()));
// return the bounding box object
return boundingBox;
}
@Test
public void testNoApiLimitOnRootAdmin() throws Exception {
// issue list Accounts calls
final HashMap<String, String> params = new HashMap<String, String>();
params.put("response", "json");
params.put("listAll", "true");
params.put("sessionkey", sessionKey);
// assuming ApiRateLimitService set api.throttling.max = 25
int clientCount = 26;
Runnable[] clients = new Runnable[clientCount];
final boolean[] isUsable = new boolean[clientCount];
final CountDownLatch startGate = new CountDownLatch(1);
final CountDownLatch endGate = new CountDownLatch(clientCount);
for (int i = 0; i < isUsable.length; ++i) {
final int j = i;
clients[j] =
new Runnable() {
/** {@inheritDoc} */
@Override
public void run() {
try {
startGate.await();
sendRequest("listAccounts", params);
isUsable[j] = true;
} catch (CloudRuntimeException e) {
isUsable[j] = false;
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
endGate.countDown();
}
}
};
}
ExecutorService executor = Executors.newFixedThreadPool(clientCount);
for (Runnable runnable : clients) {
executor.execute(runnable);
}
startGate.countDown();
endGate.await();
int rejectCount = 0;
for (int i = 0; i < isUsable.length; ++i) {
if (!isUsable[i]) rejectCount++;
}
assertEquals("No request should be rejected!", 0, rejectCount);
}
public ActionForward updateAppointmentReason(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HashMap<String, Object> hashMap = new HashMap<String, Object>();
OscarAppointmentDao appointmentDao =
(OscarAppointmentDao) SpringUtils.getBean("oscarAppointmentDao");
Appointment appointment =
appointmentDao.find(Integer.parseInt(request.getParameter("appointmentNo")));
if (appointment != null) {
appointment.setReason(request.getParameter("reason"));
appointmentDao.merge(appointment);
hashMap.put("success", true);
hashMap.put("appointmentNo", appointment.getId());
}
JsonConfig config = new JsonConfig();
config.registerJsonBeanProcessor(java.sql.Date.class, new JsDateJsonBeanProcessor());
JSONObject json = JSONObject.fromObject(hashMap, config);
response.getOutputStream().write(json.toString().getBytes());
return null;
}
public static List<String> findTopKWinner(int time, Vector<LogEntry> logs, int k) {
List<String> result = new ArrayList<String>();
HashMap<String, Integer> map = new HashMap<String, Integer>();
for (LogEntry log : logs) {
if (log.time <= time) {
if (map.containsKey(log.candidate)) map.put(log.candidate, map.get(log.candidate) + 1);
else map.put(log.candidate, 1);
}
}
ArrayList<Integer> a = new ArrayList<Integer>();
for (String str : map.keySet()) a.add(map.get(str));
// find top K in a
// method1: Using PriorityQuene. time complexity: (nlgn+k)
// method2: Using quick select
quickSelect(a, 0, a.size() - 1, a.size() - k + 1);
System.out.println(a);
for (int i = a.size() - k; i < a.size(); i++) {
int value = a.get(i);
for (String str : map.keySet()) {
if (map.get(str) == value) result.add(str);
}
}
return result;
}
public void assertAll(Iterable<Diagnostic> asserted, DiagnosticPredicate predicates[]) {
HashMap<DiagnosticPredicate, Boolean> consumed = new HashMap<DiagnosticPredicate, Boolean>();
for (DiagnosticPredicate p : predicates) consumed.put(p, Boolean.FALSE);
for (Diagnostic d : asserted) {
boolean found = false;
for (Entry<DiagnosticPredicate, Boolean> e : consumed.entrySet())
if ((!e.getValue() || e.getKey().isGreedy()) && e.getKey().apply(d)) {
consumed.put(e.getKey(), Boolean.TRUE);
found = true;
break;
}
if (!found) {
if (predicates.length == 1)
throw new ComparisonFailure(
"Predicate does not match", predicates[0].toString(), diagnosticsToString(d));
throw new ComparisonFailure(
"No predicate in expected matches",
Arrays.toString(predicates),
diagnosticsToString(d));
}
}
ArrayList<DiagnosticPredicate> unconsumed = new ArrayList<DiagnosticPredicate>();
for (Entry<DiagnosticPredicate, Boolean> e : consumed.entrySet())
if (!e.getValue() && e.getKey().isRequired()) unconsumed.add(e.getKey());
if (unconsumed.size() != 0)
throw new ComparisonFailure(
"Missing diagnostics for required predicates",
Arrays.toString(unconsumed.toArray()),
diagnosticsToString(asserted));
}
@Test
public void testDocumentationExample() throws Exception {
initTestData();
String script =
"term = _index['float_payload_field'].get('b',"
+ includeAllFlag
+ "); payloadSum=0; for (pos in term) {payloadSum = pos.payloadAsInt(0)}; payloadSum";
// non existing field: sum should be 0
HashMap<String, Object> zeroArray = new HashMap<>();
zeroArray.put("1", 0);
zeroArray.put("2", 0);
zeroArray.put("3", 0);
checkValueInEachDoc(script, zeroArray, 3);
script =
"term = _index['int_payload_field'].get('b',"
+ includeAllFlag
+ "); payloadSum=0; for (pos in term) {payloadSum = payloadSum + pos.payloadAsInt(0)}; payloadSum";
// existing field: sums should be as here:
zeroArray.put("1", 5);
zeroArray.put("2", 3);
zeroArray.put("3", 1);
checkValueInEachDoc(script, zeroArray, 3);
}
/**
* Constructor. The first time an RJavaClassLoader is created, it is cached as the primary loader.
*
* @param path path of the rJava package
* @param libpath lib sub directory of the rJava package
*/
public RJavaClassLoader(String path, String libpath) {
super(new URL[] {});
// respect rJava.debug level
String rjd = System.getProperty("rJava.debug");
if (rjd != null && rjd.length() > 0 && !rjd.equals("0")) verbose = true;
if (verbose) System.out.println("RJavaClassLoader(\"" + path + "\",\"" + libpath + "\")");
if (primaryLoader == null) {
primaryLoader = this;
if (verbose) System.out.println(" - primary loader");
} else {
if (verbose)
System.out.println(" - NOT primrary (this=" + this + ", primary=" + primaryLoader + ")");
}
libMap = new HashMap /*<String,UnixFile>*/();
classPath = new Vector /*<UnixFile>*/();
classPath.add(new UnixDirectory(path + "/java"));
rJavaPath = path;
rJavaLibPath = libpath;
/* load the rJava library */
UnixFile so = new UnixFile(rJavaLibPath + "/rJava.so");
if (!so.exists()) so = new UnixFile(rJavaLibPath + "/rJava.dll");
if (so.exists()) libMap.put("rJava", so);
/* load the jri library */
UnixFile jri = new UnixFile(path + "/jri/libjri.so");
String rarch = System.getProperty("r.arch");
if (rarch != null && rarch.length() > 0) {
UnixFile af = new UnixFile(path + "/jri" + rarch + "/libjri.so");
if (af.exists()) jri = af;
else {
af = new UnixFile(path + "/jri" + rarch + "/jri.dll");
if (af.exists()) jri = af;
}
}
if (!jri.exists()) jri = new UnixFile(path + "/jri/libjri.jnilib");
if (!jri.exists()) jri = new UnixFile(path + "/jri/jri.dll");
if (jri.exists()) {
libMap.put("jri", jri);
if (verbose) System.out.println(" - registered JRI: " + jri);
}
/* if we are the primary loader, make us the context loader so
projects that rely on the context loader pick us */
if (primaryLoader == this) Thread.currentThread().setContextClassLoader(this);
if (verbose) {
System.out.println("RJavaClassLoader initialized.\n\nRegistered libraries:");
for (Iterator entries = libMap.keySet().iterator(); entries.hasNext(); ) {
Object key = entries.next();
System.out.println(" " + key + ": '" + libMap.get(key) + "'");
}
System.out.println("\nRegistered class paths:");
for (Enumeration e = classPath.elements(); e.hasMoreElements(); )
System.out.println(" '" + e.nextElement() + "'");
System.out.println("\n-- end of class loader report --");
}
}
public int lengthOfLongestSubstring(String s) {
if (s == null || s.length() <= 0) return 0;
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
int result = 1;
int setSize = 1; // 窗口[i,j]中字符种类数
int i = 0;
int j = 0;
map.put(s.charAt(i), 1);
while (j < s.length()) {
System.out.println(i + " " + j + " " + setSize + " " + (setSize == j - i + 1));
if (j - i + 1 == setSize) { // substring without repeating characters
if (j - i + 1 > result) result = j - i + 1;
if (++j >= s.length()) break;
Integer t = map.get(s.charAt(j));
if (t == null || t == 0) setSize++;
map.put(s.charAt(j), t == null ? 1 : t + 1);
} else { // substring with repeating characters
Integer t = map.get(s.charAt(i));
if (t == 1) setSize--;
map.put(s.charAt(i), t - 1);
i++;
}
}
return result;
}
/** Tests partition operations */
@Test
public void testPartitionOps()
throws MetaException, InvalidObjectException, NoSuchObjectException, InvalidInputException {
Database db1 = new Database(DB1, "description", "locationurl", null);
objectStore.createDatabase(db1);
StorageDescriptor sd =
new StorageDescriptor(
null,
"location",
null,
null,
false,
0,
new SerDeInfo("SerDeName", "serializationLib", null),
null,
null,
null);
HashMap<String, String> tableParams = new HashMap<String, String>();
tableParams.put("EXTERNAL", "false");
FieldSchema partitionKey1 = new FieldSchema("Country", "String", "");
FieldSchema partitionKey2 = new FieldSchema("State", "String", "");
Table tbl1 =
new Table(
TABLE1,
DB1,
"owner",
1,
2,
3,
sd,
Arrays.asList(partitionKey1, partitionKey2),
tableParams,
"viewOriginalText",
"viewExpandedText",
"MANAGED_TABLE");
objectStore.createTable(tbl1);
HashMap<String, String> partitionParams = new HashMap<String, String>();
partitionParams.put("PARTITION_LEVEL_PRIVILEGE", "true");
List<String> value1 = Arrays.asList("US", "CA");
Partition part1 = new Partition(value1, DB1, TABLE1, 111, 111, sd, partitionParams);
objectStore.addPartition(part1);
List<String> value2 = Arrays.asList("US", "MA");
Partition part2 = new Partition(value2, DB1, TABLE1, 222, 222, sd, partitionParams);
objectStore.addPartition(part2);
Deadline.startTimer("getPartition");
List<Partition> partitions = objectStore.getPartitions(DB1, TABLE1, 10);
Assert.assertEquals(2, partitions.size());
Assert.assertEquals(111, partitions.get(0).getCreateTime());
Assert.assertEquals(222, partitions.get(1).getCreateTime());
objectStore.dropPartition(DB1, TABLE1, value1);
partitions = objectStore.getPartitions(DB1, TABLE1, 10);
Assert.assertEquals(1, partitions.size());
Assert.assertEquals(222, partitions.get(0).getCreateTime());
objectStore.dropPartition(DB1, TABLE1, value2);
objectStore.dropTable(DB1, TABLE1);
objectStore.dropDatabase(DB1);
}
public void execute(final Context context, boolean force) {
if (this.enabled(context) && this._action != null) {
final Trigger me = this;
Runnable r =
new Runnable() {
public void run() {
try {
BaseScriptEngine.runScript(context, me._action);
} catch (Exception e) {
LogManager.getInstance(context).logException(e);
HashMap<String, Object> payload = new HashMap<String, Object>();
payload.put("script", me._action);
LogManager.getInstance(context).log("failed_trigger_script", payload);
}
}
};
Thread t = new Thread(new ThreadGroup("Triggers"), r, this.name(), 32768);
t.start();
HashMap<String, Object> payload = new HashMap<String, Object>();
payload.put("name", this.name());
payload.put("identifier", this.identifier());
payload.put("action", this._action);
LogManager.getInstance(context).log("pr_trigger_fired", payload);
}
}
public static void readRatingData(String fileName, String split) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(fileName));
HashMap<String, Float> hashUserRating;
Set<String> setMovies;
String s = "";
while ((s = br.readLine()) != null) {
String[] temp = s.split(split);
String userid = temp[0];
String movieid = temp[1];
float rating = Float.parseFloat(temp[2]);
if (hashUserMovie.containsKey(userid)) {
setMovies = hashUserMovie.get(userid);
setMovies.add(movieid);
hashUserMovie.put(userid, setMovies);
} else {
setMovies = new HashSet<String>();
setMovies.add(movieid);
hashUserMovie.put(userid, setMovies);
}
if (hashMovieUserRating.containsKey(movieid)) {
hashUserRating = hashMovieUserRating.get(movieid);
hashUserRating.put(userid, rating);
hashMovieUserRating.put(movieid, hashUserRating);
} else {
hashUserRating = new HashMap<String, Float>();
hashUserRating.put(userid, rating);
hashMovieUserRating.put(movieid, hashUserRating);
}
}
br.close();
}
/**
* AUTOR Y FECHA CREACION: JCHAVEZ / 26-08-2013 OBTENER MONTOS TOTALES POR EMPRESA-DESCUENTA Y
* PERIODO (ESTADO DE CUENTA - TAB TERCEROS)
*/
public List<Descuento> getMontoTotalPorNomCptoYPeriodo(
String strDsteCpto,
String strNomCpto,
Integer intPeriodo,
Integer intMes,
Integer intParaModalidadCod,
String strLibEle)
throws BusinessException {
List<Descuento> lista = null;
try {
HashMap<String, Object> mapa = new HashMap<String, Object>();
mapa.put("strDsteCpto", strDsteCpto);
mapa.put("strNomCpto", strNomCpto);
mapa.put("intPeriodo", intPeriodo);
mapa.put("intMes", intMes);
mapa.put("intParaModalidadCod", intParaModalidadCod);
mapa.put("strLibEle", strLibEle);
lista = dao.getMontoTotalPorNomCptoYPeriodo(mapa);
} catch (DAOException e) {
throw new BusinessException(e);
} catch (Exception e) {
throw new BusinessException(e);
}
return lista;
}
public void testRangeValidation() {
HashMap<String, String> params = new HashMap<String, String>();
params.put("longFoo", "200");
HashMap<String, Object> extraContext = new HashMap<String, Object>();
extraContext.put(ActionContext.PARAMETERS, params);
try {
ActionProxy proxy =
actionProxyFactory.createActionProxy(
"", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
proxy.execute();
assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
Map errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
List errorMessages = (List) errors.get("longFoo");
assertEquals(1, errorMessages.size());
String errorMessage = (String) errorMessages.get(0);
assertNotNull(errorMessage);
} catch (Exception e) {
e.printStackTrace();
fail();
}
}
public static void main(String[] args) {
buckets = new HashMap<String, Integer>();
String dict = "ia mbn";
String word = "Four score and seven years ago";
for (int i = 0; i < dict.length(); i++) {
char x = dict.charAt(i);
buckets.put(String.valueOf(x), new Integer(0));
}
StringBuilder output = new StringBuilder("");
for (int i = 0; i < word.length(); i++) {
String c = String.valueOf(word.charAt(i));
if (buckets.containsKey(c)) {
Integer bucket = buckets.get(c);
bucket++;
buckets.put(c, bucket);
} else {
output.append(c);
}
}
for (int i = 0; i < dict.length(); i++) {
String c = String.valueOf(dict.charAt(i));
Integer k = buckets.get(c);
for (int j = 0; j < k; j++) {
output.append(c);
}
}
System.out.println(output);
}
public static HashMap<String, Integer> getAnimeSearchedMAL(
String username, String password, String anime) {
HashMap<String, Integer> map = new HashMap<String, Integer>();
JSONObject xmlJSONObj;
String json = "";
String xml = "";
try {
xml = searchAnimeMAL(username, password, anime);
xmlJSONObj = XML.toJSONObject(xml);
json = xmlJSONObj.toString(4);
} catch (Exception e) {
MAMUtil.writeLog(e);
e.printStackTrace();
}
JsonParser parser = new JsonParser();
JsonObject root = parser.parse(json).getAsJsonObject();
if (root.has("anime") && root.get("anime").getAsJsonObject().get("entry").isJsonArray()) {
JsonArray searchedAnime = root.get("anime").getAsJsonObject().get("entry").getAsJsonArray();
for (JsonElement obj : searchedAnime) {
String name = obj.getAsJsonObject().get("title").getAsString();
int id = obj.getAsJsonObject().get("id").getAsInt();
map.put(name, id);
}
} else if (root.has("anime")) {
JsonObject obj = root.get("anime").getAsJsonObject().get("entry").getAsJsonObject();
int id = obj.getAsJsonObject().get("id").getAsInt();
map.put(anime, id);
}
return map;
}
/** Add a value with a weight to the set. */
public void add(double value, double weight) {
if (valueMap.containsKey(value)) {
valueMap.put(value, valueMap.get(value) + weight);
} else {
valueMap.put(value, weight);
}
}
@Test
public void testGetApiLimitOnUser() throws Exception {
// log in using normal user
login("demo", "password");
// issue an api call
HashMap<String, String> params = new HashMap<String, String>();
params.put("response", "json");
params.put("listAll", "true");
params.put("sessionkey", sessionKey);
sendRequest("listAccounts", params);
// issue get api limit calls
final HashMap<String, String> params2 = new HashMap<String, String>();
params2.put("response", "json");
params2.put("sessionkey", sessionKey);
String getResult = sendRequest("getApiLimit", params2);
ApiLimitResponse getLimitResp =
(ApiLimitResponse) fromSerializedString(getResult, ApiLimitResponse.class);
assertEquals(
"Issued api count is incorrect!",
2,
getLimitResp.getApiIssued()); // should be 2 apis issues plus this getlimit api
assertEquals("Allowed api count is incorrect!", apiMax - 2, getLimitResp.getApiAllowed());
}
@Override
public Long getUniqueDevicesSupportingBluetooth(
Company company, Date eventDate, Campaign campaign, Device device) {
String query =
"SELECT COUNT(DISTINCT b.macAddress) FROM BluetoothSend b WHERE b.eventDate BETWEEN ?1 AND ?2 AND b.company = ?3 AND b.sendStatus in (1, 2, 3, 4, 5, 7) ";
int paramCount = 3;
HashMap<Integer, Object> params = new HashMap<Integer, Object>();
if (campaign != null) {
paramCount++;
query += " AND b.campaign = ?" + paramCount + " ";
params.put(paramCount, campaign);
}
if (device != null) {
paramCount++;
query += " AND b.device = ?" + paramCount + " ";
params.put(paramCount, device);
}
Query q = em.createQuery(query);
q.setParameter(1, eventDate);
q.setParameter(2, DateUtil.getEndOfDay(eventDate));
q.setParameter(3, company);
for (Map.Entry<Integer, Object> entry : params.entrySet()) {
Integer paramId = entry.getKey();
Object object = entry.getValue();
q.setParameter(paramId, object);
}
Long countResult = (Long) q.getSingleResult();
return countResult;
}
static {
sHistoryProjectionMap = new HashMap<String, String>();
sHistoryProjectionMap.put(ChatHistoryTable._ID, ChatHistoryTable._ID);
sHistoryProjectionMap.put(ChatHistoryTable.CHAT_ASK, ChatHistoryTable.CHAT_ASK);
sHistoryProjectionMap.put(ChatHistoryTable.CHAT_ANSWER, ChatHistoryTable.CHAT_ANSWER);
sHistoryProjectionMap.put(ChatHistoryTable.CHAT_TIME, ChatHistoryTable.CHAT_TIME);
}
@Override
public Long getUniqueDevicesAcceptingPush(
Company company, Date eventDate, Campaign campaign, Device device) {
String query =
"SELECT COUNT(DISTINCT b.macAddress) FROM BluetoothSend b WHERE (b.acceptStatus = ?1 OR b.sendStatus = ?2) AND b.eventDate BETWEEN ?3 AND ?4 AND b.company = ?5 ";
int paramCount = 5;
HashMap<Integer, Object> params = new HashMap<Integer, Object>();
if (campaign != null) {
paramCount++;
query += " AND b.campaign = ?" + paramCount + " ";
params.put(paramCount, campaign);
}
if (device != null) {
paramCount++;
query += " AND b.device = ?" + paramCount + " ";
params.put(paramCount, device);
}
Query q = em.createQuery(query);
q.setParameter(1, 1);
q.setParameter(2, BluetoothSend.STATUS_ACCEPTED);
q.setParameter(3, eventDate);
q.setParameter(4, DateUtil.getEndOfDay(eventDate));
q.setParameter(5, company);
for (Map.Entry<Integer, Object> entry : params.entrySet()) {
Integer paramId = entry.getKey();
Object object = entry.getValue();
q.setParameter(paramId, object);
}
Long countResult = (Long) q.getSingleResult();
return countResult;
}
public HashMap getAllRateCodes() {
/**
* Requires - Modifies - Effects -
*
* @throws -
*/
Criteria objCriteria = null;
Session objSession = null;
Integer totRecordCount = null;
List objList = null;
HashMap hmResult = new HashMap();
try {
logger.info("GETTING ALL RATE CODES");
objSession = HibernateUtil.getSession();
objCriteria = objSession.createCriteria(RateCodesVO.class);
totRecordCount = new Integer(objCriteria.list().size());
objList = objCriteria.list();
hmResult.put("TotalRecordCount", totRecordCount);
hmResult.put("Records", objList);
logger.info("GOT ALL RATE CODES");
} catch (HibernateException e) {
logger.error("HIBERNATE EXCEPTION DURING GET ALL RATE CODES", e);
e.printStackTrace();
} finally {
if (objSession != null) {
objSession.close();
}
}
return hmResult;
}
@Override
public Long getTotalContentDownloads(
Company company, Date eventDate, Campaign campaign, Device device) {
String query =
"SELECT COUNT(b.id) FROM BluetoothSend b WHERE b.sendStatus = ?1 AND b.eventDate BETWEEN ?2 AND ?3 AND b.company = ?4 ";
int paramCount = 4;
HashMap<Integer, Object> params = new HashMap<Integer, Object>();
if (campaign != null) {
paramCount++;
query += " AND b.campaign = ?" + paramCount + " ";
params.put(paramCount, campaign);
}
if (device != null) {
paramCount++;
query += " AND b.device = ?" + paramCount + " ";
params.put(paramCount, device);
}
Query q = em.createQuery(query);
q.setParameter(1, BluetoothSend.STATUS_SENT);
q.setParameter(2, eventDate);
q.setParameter(3, DateUtil.getEndOfDay(eventDate));
q.setParameter(4, company);
for (Map.Entry<Integer, Object> entry : params.entrySet()) {
Integer paramId = entry.getKey();
Object object = entry.getValue();
q.setParameter(paramId, object);
}
Long countResult = (Long) q.getSingleResult();
return countResult;
}
/**
* fills the list with stops from the local database
*
* @param db the database adapter to use
*/
private void fillList(BusDbAdapter db) {
Cursor c;
if (listType == FAVORITES) {
c = db.getFavoriteDest(NUM_ENTRIES_TO_FETCH);
} else { // listType == MAJOR
c = db.getMajorDest(NUM_ENTRIES_TO_FETCH);
}
int stopIDIndex = c.getColumnIndex("stop_id");
int stopDescIndex = c.getColumnIndex("stop_desc");
int routeIDIndex = c.getColumnIndex("route_id");
int routeDescIndex = c.getColumnIndex("route_desc");
if (c != null) {
for (int i = 0; i < c.getCount(); i++) {
HashMap<String, String> item = new HashMap<String, String>();
String stopID = c.getString(stopIDIndex);
String stopName = c.getString(stopDescIndex);
String route = c.getString(routeIDIndex);
String routeDesc = c.getString(routeDescIndex);
Log.v(TAG, "PUT");
Log.v(TAG, "stopID " + stopID + " stopName " + stopName);
Log.v(TAG, "routeID " + route + " routeDesc" + routeDesc);
item.put("stopID", stopID);
item.put("stopName", stopName);
item.put("routeID", route);
item.put("routeDesc", routeDesc);
c.moveToNext();
locationList.add(item);
}
listAdapter.notifyDataSetChanged();
}
}
@Override
public List<BluetoothFileSendSummary> fetchBluetoothFileSendSummaries(
Date eventDate, Company company, Campaign campaign, Device device) {
String query =
"SELECT b FROM BluetoothFileSendSummary b WHERE b.eventDate BETWEEN ?1 AND ?2 AND b.company = ?3 ";
int paramCount = 3;
HashMap<Integer, Object> params = new HashMap<Integer, Object>();
if (campaign != null) {
paramCount++;
query += " AND b.campaign = ?" + paramCount + " ";
params.put(paramCount, campaign);
}
if (device != null) {
paramCount++;
query += " AND b.device = ?" + paramCount + " ";
params.put(paramCount, device);
}
Query q = em.createQuery(query);
q.setParameter(1, eventDate);
q.setParameter(2, DateUtil.getEndOfDay(eventDate));
q.setParameter(3, company);
for (Map.Entry<Integer, Object> entry : params.entrySet()) {
Integer paramId = entry.getKey();
Object object = entry.getValue();
q.setParameter(paramId, object);
}
List<BluetoothFileSendSummary> results = (List<BluetoothFileSendSummary>) q.getResultList();
return results;
}
@GET
@Path("/{reviewId}")
@Timed(name = "view-book-by-reviewId")
public Response viewBookReview(
@PathParam("isbn") LongParam isbn, @PathParam("reviewId") IntParam reviewId) {
Book book = bookRepository.getBookByISBN(isbn.get());
ReviewDto reviewResponse = null;
List<Review> reviewList = book.getReview();
List<Review> tempList = new ArrayList<Review>();
for (Review reviewObj : reviewList) {
if (reviewObj.getId() == reviewId.get()) tempList.add(reviewObj);
}
reviewResponse = new ReviewDto(tempList);
String location = "/books/" + book.getIsbn() + "/reviews/";
HashMap<String, Object> map = new HashMap<String, Object>();
Review review = reviewResponse.getReviewList().get(0);
map.put("review", review);
reviewResponse.addLink(new LinkDto("view-review", location + reviewId.get(), "GET"));
map.put("links", reviewResponse.getLinks());
return Response.status(200).entity(map).build();
}
public static void NIOReadTest() {
long st = System.currentTimeMillis();
String fileName = "/data/glassfish/bak/CS_AIU_MM/CITY_86020/combine.dat";
int rNum = 700;
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
for (int i = 0; i < rNum; i++) hm.put(i, 0);
int cc = 0;
try {
List<String> lines = Files.readAllLines(Paths.get(fileName), Charset.defaultCharset());
for (String line : lines) {
String r[] = StrUtils.split(line, ",");
int salt = generatetRowKeySalt(r, 14, rNum);
if (salt != -1) {
int counter = hm.get(salt);
counter++;
hm.put(salt, counter);
} else cc++;
}
long et = System.currentTimeMillis();
System.out.println("UsedTime:" + (et - st));
} catch (IOException e) {
e.printStackTrace();
}
}