@Override
public Predicate toPredicate(Root<Role> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
Predicate predicate = cb.conjunction();
List<Expression<Boolean>> expressions = predicate.getExpressions();
if (isNotBlank(criteria.getFilter())) {
expressions.add(
cb.or(
cb.like(
cb.lower(root.<String>get(Role_.roleName)),
wildcardsAndLower(criteria.getFilter())),
cb.like(
cb.lower(root.<String>get(Role_.roleDesc)),
wildcardsAndLower(criteria.getFilter()))));
}
if (isNotBlank(criteria.getRoleName())) {
expressions.add(
cb.like(
cb.lower(root.<String>get(Role_.roleName)),
wildcardsAndLower(criteria.getRoleName())));
}
if (isNotBlank(criteria.getRoleDesc())) {
expressions.add(
cb.like(
cb.lower(root.<String>get(Role_.roleDesc)),
wildcardsAndLower(criteria.getRoleDesc())));
}
if (null != criteria.getIsSys()) {
expressions.add(cb.equal(root.<Boolean>get(Role_.isSys), criteria.getIsSys()));
}
return predicate;
}
public Object getWriteControlObject() {
Root root = new Root();
HashMap any = new HashMap();
root.setAny(any);
return root;
}
public static CriteriaQuery<Organization> buildSearchQuery(
String name,
String email,
String phone,
String type,
String region,
String district,
String locality,
String streetToSearch,
String sortCriteria,
String sortOrder,
EntityManager em) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Organization> criteriaQuery = cb.createQuery(Organization.class);
Root<Organization> root = criteriaQuery.from(Organization.class);
Predicate predicate =
ArchivalOrganizationsQueryConstructorAdmin.buildPredicate(
name, email, type, phone, region, district, locality, streetToSearch, root, cb);
if ((sortCriteria != null) && (sortOrder != null)) {
criteriaQuery.orderBy(
SortCriteriaOrganization.valueOf(sortCriteria.toUpperCase())
.getSortOrder(root, cb, sortOrder));
} else {
criteriaQuery.orderBy(cb.desc(root.get("id")));
}
criteriaQuery.select(root);
criteriaQuery.where(predicate);
return criteriaQuery;
}
private void parseGson() {
/* lib Gson */
try {
BufferedReader bufferedReader = new BufferedReader(new FileReader(this.filename));
Gson gson = new Gson();
/* Date view */
// Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-DD HH:mm").create();
Root root = gson.fromJson(bufferedReader, Root.class);
List<Weather> wh = root.getWeather();
for (int i = 0; i < wh.size(); i++) {
int id = wh.get(i).getId();
// System.out.println(id);
String title = wh.get(i).getTitle();
// System.out.println(title);
}
/* Из объекта в JSON */
// String json = gson.toJson(root);
System.out.println(root.toString());
} catch (IOException e) {
System.out.print(e.getMessage());
} catch (Exception e) {
System.out.print(e.getMessage());
}
}
public static void parseJsonUsingJackson() {
try {
ObjectMapper objectMapper = new ObjectMapper();
// convert json string to object
Root root = objectMapper.readValue(new File("test.json"), Root.class);
List<People> list = root.getPeople();
for (int i = 0; i < list.size(); i++) {
String id = String.valueOf(list.get(i).getId());
System.out.println("id: " + id + "\t");
String peopleName = list.get(i).getName();
System.out.println("Name: " + peopleName + "\t");
String peopleSurname = list.get(i).getSurname();
System.out.println("Surname: " + peopleSurname + "\t");
String peopleAge = String.valueOf(list.get(i).getAge());
System.out.println("Age: " + peopleAge + "\t");
String peopleIsDegree = String.valueOf(list.get(i).isDegree());
System.out.println("Degree: " + peopleIsDegree);
System.out.println();
}
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (JsonParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
void show(Root root) {
_target = root;
_hostname.setText(root.getRegistryInfo().hostname);
_applications.setSortedMap(root.getApplicationMap());
_objects.setObjects(root.getObjects());
_adapters.setAdapters(root.getAdapters());
}
/**
* From the dialog collects roots and commits to be pushed.
*
* @return roots to be pushed.
*/
private Collection<Root> getRootsToPush() {
final ArrayList<Root> rootsToPush = new ArrayList<Root>();
for (int i = 0; i < myTreeRoot.getChildCount(); i++) {
CheckedTreeNode node = (CheckedTreeNode) myTreeRoot.getChildAt(i);
Root r = (Root) node.getUserObject();
if (r.remoteName == null || r.commits.size() == 0) {
continue;
}
boolean topCommit = true;
for (int j = 0; j < node.getChildCount(); j++) {
if (node.getChildAt(j) instanceof CheckedTreeNode) {
CheckedTreeNode commitNode = (CheckedTreeNode) node.getChildAt(j);
if (commitNode.isChecked()) {
Commit commit = (Commit) commitNode.getUserObject();
if (!topCommit) {
r.commitToPush = commit.revision.asString();
}
rootsToPush.add(r);
break;
}
topCommit = false;
}
}
}
return rootsToPush;
}
private <C, X> Subquery<?> createCountSubQuery(
Root<T> root,
CriteriaQuery<Long> countQuery,
Selections<T, C, X> selection,
CriteriaBuilder builder,
Specification<T> spec,
List<Expression<?>> groupBy,
Predicate having) {
Subquery<?> subquery = countQuery.subquery(entityInformation.getIdType());
Root subRoot = subquery.from(entityInformation.getJavaType());
Expression[] select = selection.select(subRoot, (AbstractQuery<C>) subquery, builder);
subquery.select(select[0]);
selection.join(subRoot, builder);
Predicate predicate =
builder.equal(
subRoot.get(entityInformation.getIdAttribute()),
root.get(entityInformation.getIdAttribute()));
if (predicate != null) {
subquery.where(predicate);
}
if (groupBy != null) {
subquery.groupBy(groupBy);
}
if (having != null) {
subquery.having(having);
}
return subquery;
}
protected Object getControlObject() {
Root r = new Root();
r.myString1 = "100";
r.myString2 = "200";
r.myString3 = "5th of April, 2015";
return r;
}
public Object getControlObject() {
Root root = new Root();
Vector any = new Vector();
any.addElement("root's text");
root.setAny(any);
return root;
}
@SuppressWarnings("unchecked")
public static Predicate[] deviceListPredicates(
CriteriaBuilder cb,
Root<Device> from,
Optional<String> name,
Optional<String> namePattern,
Optional<String> status,
Optional<Long> networkId,
Optional<String> networkName,
Optional<Long> deviceClassId,
Optional<String> deviceClassName,
Optional<String> deviceClassVersion,
Optional<HivePrincipal> principal) {
final List<Predicate> predicates = new LinkedList<>();
name.ifPresent(n -> predicates.add(cb.equal(from.<String>get("name"), n)));
namePattern.ifPresent(np -> predicates.add(cb.like(from.<String>get("name"), np)));
status.ifPresent(s -> predicates.add(cb.equal(from.<String>get("status"), s)));
final Join<Device, Network> networkJoin = (Join) from.fetch("network", JoinType.LEFT);
networkId.ifPresent(nId -> predicates.add(cb.equal(networkJoin.<Long>get("id"), nId)));
networkName.ifPresent(
nName -> predicates.add(cb.equal(networkJoin.<String>get("name"), nName)));
final Join<Device, DeviceClass> dcJoin = (Join) from.fetch("deviceClass", JoinType.LEFT);
deviceClassId.ifPresent(dcId -> predicates.add(cb.equal(dcJoin.<Long>get("id"), dcId)));
deviceClassName.ifPresent(
dcName -> predicates.add(cb.equal(dcJoin.<String>get("name"), dcName)));
deviceClassVersion.ifPresent(
dcVersion -> predicates.add(cb.equal(dcJoin.<String>get("version"), dcVersion)));
predicates.addAll(deviceSpecificPrincipalPredicates(cb, from, principal));
return predicates.toArray(new Predicate[predicates.size()]);
}
/** {@inheritDoc} */
@Override
public void insert(final GedObject owner, final GedObject gob) {
if (!(owner instanceof Root)) {
return;
}
final Root root = (Root) owner;
root.insert(gob.getString(), gob);
}
/** {@inheritDoc} */
@Override
public String getDbName(final GedObject owner) {
if (!(owner instanceof Root)) {
return null;
}
final Root root = (Root) owner;
return root.getTheDbName();
}
/** {@inheritDoc} */
@Override
public GedObject find(final GedObject owner, final String str) {
if (!(owner instanceof Root)) {
return null;
}
final Root root = (Root) owner;
return root.getObjects().get(str);
}
public Object getControlObject() {
Root root = new Root();
HashMap any = new HashMap();
QName name = new QName("http://www.w3.org/2000/xmlns/", "myns");
any.put(name, "www.example.com/some-dir/some.xsd");
root.setAny(any);
// System.out.println(root);
return root;
}
/** Measures memory usage information and stores it in the model. */
public static void main(String[] args) throws IOException, ClassNotFoundException {
Root root = Root.fromFile(args[0]);
root.baseline = baseline();
for (LoadedClass loadedClass : root.loadedClasses.values()) {
if (loadedClass.systemClass) {
loadedClass.measureMemoryUsage();
}
}
root.toFile(args[0]);
}
protected void discardUpdate() {
Root root = _target.getRoot();
if (_target.isEphemeral()) {
_target.delete();
} else {
_target.getCoordinator().getCurrentTab().showNode(_target);
}
root.cancelEdit();
}
public Object getControlObject() {
Root root = new Root();
XMLRoot xmlroot = new XMLRoot();
xmlroot.setObject("child's text");
xmlroot.setLocalName("myns:theXMLRoot");
xmlroot.setNamespaceURI("www.example.com/some-dir/some.xsd");
root.setAny(xmlroot);
return root;
}
public Object getControlObject() {
Root root = new Root();
HashMap any = new HashMap();
QName name = new QName("www.example.com/some-dir/some.xsd", "first-name");
any.put(name, "Matt");
name = new QName("www.example.com/some-dir/some.xsd", "last-name");
any.put(name, "MacIvor");
root.setAny(any);
return root;
}
/**
* @return
* @throws Exception
*/
public Tuple<Integer, Integer> uct(int n) throws Exception {
while (n > 0) {
System.out.println(n);
Board tempBoard = this.board.duplicate();
Node node = treePolicy(root.getRoot(), tempBoard);
String delta = defaultPolicy(node, tempBoard);
back_up(node, delta);
--n;
}
return bestChild(root.getRoot(), 0).getMove();
}
/**
* Adds ORDER BY ... ASC/DESC to query Mutates provided criteria query
*
* @param sortFieldOpt - field to sort by (field name in JPA Entity class)
* @param asc - true if order should be ASC, false otherwise
*/
public static void order(
CriteriaBuilder cb,
CriteriaQuery<?> cq,
Root<?> from,
Optional<String> sortFieldOpt,
boolean asc) {
sortFieldOpt.ifPresent(
sortField -> {
Order order = asc ? cb.asc(from.get(sortField)) : cb.desc(from.get(sortField));
cq.orderBy(order);
});
}
public static Root processJaxbClasses(
Map<String, ApiClassDocumentation> javadocInfo, List<Class<?>> classes) {
Map<Package, String> pkgToNamespace = Maps.newHashMap();
Root root = new Root();
for (Class<?> jaxbClass : classes) {
JaxbInfo jaxbInfo = JaxbInfo.getFromCache(jaxbClass);
String namespace = getNamespace(jaxbClass, pkgToNamespace);
Service svc = root.getServiceForNamespace(namespace);
if (svc == null) {
svc = root.addService(new Service(namespace.replaceFirst("urn:", ""), namespace));
String svcDesc = serviceDescriptions.get(namespace);
if (svcDesc == null) {
throw new RuntimeException("No service description exists for namespace " + namespace);
} else {
svc.setDescription(svcDesc);
}
}
String cmdName;
Command cmd;
XmlElementDescription desc;
String className = jaxbClass.getName();
className = jaxbInfo.getRootElementName();
if (className.endsWith("Request")) {
cmdName = className.substring(0, className.lastIndexOf("Request"));
cmd = svc.getCommand(namespace, cmdName);
if (cmd == null) {
cmd = svc.addCommand(new Command(svc, cmdName, namespace));
}
desc =
XmlElementDescription.createTopLevel(
jaxbInfo, namespace, jaxbInfo.getRootElementName());
markupDuplicateElements(desc);
cmd.setDescription(desc.getDescription());
cmd.setRootRequestElement(desc);
// getJavaDocInfoForCommand(cmd, jaxbClass);
} else if (className.endsWith("Response")) {
cmdName = className.substring(0, className.lastIndexOf("Response"));
cmd = svc.getCommand(namespace, cmdName);
if (cmd == null) {
cmd = svc.addCommand(new Command(svc, cmdName, namespace));
}
desc =
XmlElementDescription.createTopLevel(
jaxbInfo, namespace, jaxbInfo.getRootElementName());
markupDuplicateElements(desc);
cmd.setRootResponseElement(desc);
}
}
populateWithJavadocInfo(root, javadocInfo);
return root;
}
public Object getControlObject() {
Root root = new Root();
Vector any = new Vector();
Child child = new Child();
child.setContent("Child1");
any.addElement(child);
any.addElement("Root Text!!");
child = new Child();
child.setContent("Child2");
any.addElement(child);
any.addElement("More Text!!");
root.setAny(any);
return root;
}
@Override
public List<Product> getProductsByConditions(
String categoryContain, String nameContain, Float priceFrom, Float priceBefore) {
openConnection();
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Product> cq = cb.createQuery(Product.class);
Root<Product> productRoot = cq.from(Product.class);
List<Predicate> predicates = new ArrayList<Predicate>();
if (categoryContain != null) {
if (!categoryContain.equals("")) {
Expression<String> catName = productRoot.get("cat").get("name");
Predicate catNameContainPredicate = cb.like(cb.lower(catName), "%" + categoryContain + "%");
predicates.add(catNameContainPredicate);
}
}
if (nameContain != null) {
if (!nameContain.equals("")) {
Expression<String> productName = productRoot.get("name");
Predicate nameContainPredicate = cb.like(cb.lower(productName), "%" + nameContain + "%");
predicates.add(nameContainPredicate);
}
}
Expression<Float> price = productRoot.get("price");
if (priceBefore != null) {
Predicate pricePredicate = cb.between(price, priceFrom, priceBefore);
predicates.add(pricePredicate);
}
if (priceBefore == null) {
Predicate pricePredicate = cb.gt(price, priceFrom);
predicates.add(pricePredicate);
}
cq.select(productRoot);
if (predicates.size() != 0) {
Predicate[] predicatesArray = new Predicate[predicates.size()];
cq.where(predicates.toArray(predicatesArray));
}
TypedQuery<Product> productTypedQuery = entityManager.createQuery(cq);
List<Product> productList = productTypedQuery.getResultList();
closeConnection();
return DbManagerPersistence.filterProducts(productList, nameContain, categoryContain);
}
private <C, X> TypedQuery<Long> getCountQuery(
Specification<T> spec,
Selections<T, C, X> selection,
List<Expression<?>> groupBy,
Predicate having) {
CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<Long> countQuery = builder.createQuery(Long.class);
Root<T> root = countQuery.from(getDomainClass());
Subquery<?> subquery =
createCountSubQuery(root, countQuery, selection, builder, spec, groupBy, having);
Path<?> path = root.get(entityInformation.getIdAttribute());
countQuery.select(builder.countDistinct(path)).where(builder.exists(subquery));
return em.createQuery(countQuery);
}
private Root buildRoot() {
Root r = new Root();
Parent parent1 = r.addChild("Parent 1");
parent1.addChild("Foo");
parent1.addChild("Bar");
parent1.addChild("Baz");
Parent parent2 = r.addChild("Parent 2");
parent2.addChild("Joo");
parent2.addChild("Jar");
parent2.addChild("Jaz");
Parent parent3 = r.addChild("Parent 3");
parent3.addNestedChild("Too");
parent3.addNestedChild("Tar");
parent3.addNestedChild("Taz");
return r;
}
@Override
public void start(Stage stage) {
stage.setTitle("Rust Map Helper");
Data.getInstance().openDataFile("data.yml");
stage.setScene(Root.getInstance().getScene());
stage.show();
}
/*
* Liest die Scenario Informationen in die entsprechenden Objekte
* und gibt eine Liste davon zurueck. Siehe dazu auch MeteringProcessStorage.java.
* @param fileName Dateiname der Storagedatei
* @return Liste mit den Scenario-Objekte.
*/
public List getList() {
List scenariosList = new ArrayList();
try {
SAXBuilder builder = new SAXBuilder();
StorageDoc = builder.build(appPath + storageFileName);
Root = StorageDoc.getRootElement();
List scenarioChildren = Root.getChildren("scenario", ipfixConfigNS);
Iterator listIterator = scenarioChildren.iterator();
Element currentElement;
while (listIterator.hasNext()) {
currentElement = (Element) listIterator.next();
Scenario currentScenario = new Scenario();
// currentscenario.setId(Integer.valueOf(currentElement.getAttributeValue("id")));
currentScenario.setName(currentElement.getChildText("name", ipfixConfigNS));
currentScenario.setDescription(currentElement.getChildText("descript", ipfixConfigNS));
List deviceList = new ArrayList();
Element devices = currentElement.getChild("devices", ipfixConfigNS);
List childList = devices.getChildren("device", ipfixConfigNS);
Iterator devicesIterator = childList.iterator();
while (devicesIterator.hasNext()) {
Element currentDevice = (Element) devicesIterator.next();
deviceList.add(currentDevice.getText());
}
currentScenario.setDeviceList(deviceList);
scenariosList.add(currentScenario);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return scenariosList;
}
public static Predicate[] deviceClassListPredicates(
CriteriaBuilder cb,
Root<DeviceClass> from,
Optional<String> name,
Optional<String> namePattern,
Optional<String> version) {
final List<Predicate> predicates = new LinkedList<>();
if (namePattern.isPresent()) {
namePattern.ifPresent(np -> predicates.add(cb.like(from.get("name"), np)));
} else {
name.ifPresent(n -> predicates.add(cb.equal(from.get("name"), n)));
}
version.ifPresent(v -> predicates.add(cb.equal(from.get(DeviceClass.VERSION_COLUMN), v)));
return predicates.toArray(new Predicate[predicates.size()]);
}
public static Predicate[] oAuthGrantsListPredicates(
CriteriaBuilder cb,
Root<OAuthGrant> from,
User user,
Optional<Date> startOpt,
Optional<Date> endOpt,
Optional<String> oAuthIdOpt,
Optional<Integer> typeOpt,
Optional<String> scopeOpt,
Optional<String> redirectUri,
Optional<Integer> accessType) {
List<Predicate> predicates = new LinkedList<>();
if (!user.isAdmin()) {
predicates.add(from.join("user").in(user));
}
startOpt.ifPresent(start -> predicates.add(cb.greaterThan(from.get("timestamp"), start)));
endOpt.ifPresent(end -> predicates.add(cb.lessThan(from.get("timestamp"), end)));
oAuthIdOpt.ifPresent(id -> predicates.add(cb.equal(from.join("client").get("oauthId"), id)));
typeOpt.ifPresent(type -> predicates.add(cb.equal(from.get("type"), type)));
scopeOpt.ifPresent(scope -> predicates.add(cb.equal(from.get("scope"), scope)));
redirectUri.ifPresent(uri -> predicates.add(cb.equal(from.get("redirectUri"), uri)));
accessType.ifPresent(at -> predicates.add(cb.equal(from.get("accessType"), at)));
return predicates.toArray(new Predicate[predicates.size()]);
}
