text
stringlengths 10
2.72M
|
|---|
class ListNode{
int val;
ListNode next;
ListNode(int x){
val = x;
}
}
public class MiddleofLinkedList {
public static void main(String[] args) {
ListNode l1 = new ListNode(1);
// l1.next = new ListNode(2);
// l1.next.next = new ListNode(4);
ListNode res = findmiddle(l1);
System.out.println(res.val);
}
public static ListNode findmiddle(ListNode head){
if(head==null||head.next==null){
return head;
}
ListNode slow=head;
ListNode fast=head.next;
while(fast!=null){
fast=fast.next;
if(fast!=null){
fast=fast.next;
}
slow=slow.next;
}
return slow;
}
}
|
package com.bierocratie.ui.view.catalog;
import com.bierocratie.model.catalog.Beer;
import com.bierocratie.model.catalog.Capacity;
import com.bierocratie.model.catalog.Supplier;
import com.bierocratie.ui.component.AbstractMenuBar;
import com.bierocratie.ui.component.OrderMenuBar;
import com.bierocratie.ui.view.AbstractBasicModelView;
import com.vaadin.addon.jpacontainer.JPAContainer;
import com.vaadin.addon.jpacontainer.JPAContainerFactory;
import com.vaadin.addon.jpacontainer.fieldfactory.MultiSelectConverter;
import com.vaadin.addon.jpacontainer.fieldfactory.SingleSelectConverter;
import com.vaadin.data.util.BeanItem;
import com.vaadin.external.org.slf4j.Logger;
import com.vaadin.external.org.slf4j.LoggerFactory;
import com.vaadin.navigator.ViewChangeListener;
import com.vaadin.shared.ui.combobox.FilteringMode;
import com.vaadin.ui.AbstractSelect;
import com.vaadin.ui.ComboBox;
import com.vaadin.ui.Notification;
import com.vaadin.ui.OptionGroup;
public class BeerView extends AbstractBasicModelView<Beer> {
private static final Logger LOG = LoggerFactory.getLogger(BeerView.class);
@Override
protected Class<Beer> getClazz() {
return Beer.class;
}
@Override
protected String getTableName() {
return "Bières";
}
@Override
protected AbstractMenuBar getMenuBar() {
// FIXME @Inject
return new OrderMenuBar();
}
@Override
protected void createMultiSelectForm() {
//To change body of implemented methods use File | Settings | File Templates.
}
private ComboBox suppliersComboBox;
private OptionGroup capacitiesOptionGroup;
@Override
protected void buildAndBind() {
// FIXME pb accès persistenceUnitName
//final JPAContainer<Supplier> suppliers = JPAContainerFactory.make(Supplier.class, persistenceUnitName);
final JPAContainer<Supplier> suppliers = JPAContainerFactory.make(Supplier.class, "orderhelper");
suppliersComboBox = new ComboBox("Fournisseur");
suppliersComboBox.setContainerDataSource(suppliers);
suppliersComboBox.setItemCaptionMode(AbstractSelect.ItemCaptionMode.PROPERTY);
suppliersComboBox.setItemCaptionPropertyId("name");
suppliersComboBox.setConverter(new SingleSelectConverter<Supplier>(suppliersComboBox));
suppliersComboBox.setFilteringMode(FilteringMode.CONTAINS);
suppliersComboBox.setImmediate(true);
binder.bind(suppliersComboBox, "supplier");
form.addComponent(suppliersComboBox);
form.addComponent(binder.buildAndBind("Nom", "name"));
form.addComponent(binder.buildAndBind("Description", "description"));
// FIXME setConverter
// FIXME pb accès persistenceUnitName
//final JPAContainer<Capacity> capacities = JPAContainerFactory.make(Capacity.class, persistenceUnitName);
final JPAContainer<Capacity> capacities = JPAContainerFactory.make(Capacity.class, "orderhelper");
capacitiesOptionGroup = new OptionGroup("Formats");
capacitiesOptionGroup.setContainerDataSource(capacities);
capacitiesOptionGroup.setItemCaptionMode(AbstractSelect.ItemCaptionMode.PROPERTY);
capacitiesOptionGroup.setItemCaptionPropertyId("title");
capacitiesOptionGroup.setConverter(new MultiSelectConverter(capacitiesOptionGroup));
capacitiesOptionGroup.setMultiSelect(true);
capacitiesOptionGroup.setImmediate(true);
binder.bind(capacitiesOptionGroup, "availableCapacities");
form.addComponent(capacitiesOptionGroup);
}
@Override
protected void updateForm(Beer item) {
}
@Override
protected boolean isUpdateAuthorized(Beer item) {
return true;
}
@Override
protected BeanItem<Beer> createNewBeanItem() {
return new BeanItem<>(new Beer());
}
@Override
protected BeanItem<Beer> createCopiedBeanItem(Beer item) {
Beer copy = new Beer();
copy.setName(item.getName());
copy.setAbv(item.getAbv());
copy.setStyle(item.getStyle());
copy.setDescription(item.getDescription());
copy.setBrewery(item.getBrewery());
copy.setSupplier(item.getSupplier());
copy.setAvailable(item.getAvailable());
copy.setCostHT(item.getCostHT());
copy.setCapacity(item.getCapacity());
return new BeanItem<>(copy);
}
@Override
protected void setTableColumns() {
table.setVisibleColumns(new String[]{"name", "description", "supplier"});
table.setColumnHeader("name", "Nom");
table.setColumnHeader("description", "Description");
table.setColumnHeader("supplier", "Fournisseur");
}
@Override
protected void addDataToItem(Beer item) throws Exception {
}
@Override
protected void preSaveItemProcessing(Beer item) {
}
@Override
protected void postSaveItemProcessing(Beer item) {
}
@Override
protected void getMultiFormValues() {
}
@Override
protected void setItemValues(Beer item) {
}
@Override
protected void postSaveItemsProcessing() {
}
@Override
public void enter(ViewChangeListener.ViewChangeEvent event) {
if (event.getParameters() == null || event.getParameters().isEmpty()) {
suppliersComboBox.setEnabled(true);
} else {
try {
prepareFormToAddNewItem();
suppliersComboBox.setValue(Long.parseLong(event.getParameters()));
suppliersComboBox.setEnabled(false);
} catch (NumberFormatException e) {
Notification.show("Erreur de conversion de données", e.getMessage(), Notification.Type.ERROR_MESSAGE);
LOG.error(e.getMessage(), e);
}
}
}
}
|
/*
* 2012-3 Red Hat Inc. and/or its affiliates and other contributors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.overlord.rtgov.ep.mvel;
import static org.junit.Assert.*;
import org.junit.Test;
import org.overlord.rtgov.ep.mvel.MVELPredicate;
public class MVELPredicateTest {
@Test
public void testEvaluateScript() {
MVELPredicate pred=new MVELPredicate();
pred.setScript("script/Evaluate.mvel");
try {
pred.init();
} catch (Exception e) {
fail("Failed to initialize: "+e);
}
try {
if (!pred.evaluate("Test")) {
fail("Evaluation of string failed");
}
} catch (Exception e) {
fail("Failed to process: "+e);
}
try {
if (pred.evaluate(5)) {
fail("Evaluation of integer failed");
}
} catch (Exception e) {
fail("Failed to process: "+e);
}
}
@Test
public void testEvaluateExpression() {
MVELPredicate pred=new MVELPredicate();
pred.setExpression("event instanceof java.lang.String");
try {
pred.init();
} catch (Exception e) {
fail("Failed to initialize: "+e);
}
try {
if (!pred.evaluate("Test")) {
fail("Evaluation of string failed");
}
} catch (Exception e) {
fail("Failed to process: "+e);
}
try {
if (pred.evaluate(5)) {
fail("Evaluation of integer failed");
}
} catch (Exception e) {
fail("Failed to process: "+e);
}
}
}
|
package com.stark.design23.abstractfactory;
/**
* Created by Stark on 2018/1/26.
* 工厂类生产者
*/
public class FactoryBuilder {
public static ProductFactory getFactory(String type) {
switch (type) {
case "A":
return new FactoryA();
case "B":
return new FactoryB();
default:
return null;
}
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package classes;
import java.util.ArrayList;
/**
* Lists current Logged Users, and saves its patient list to be monitored
* @author Lokisley Oliveira <lokisley at hotmail.com>
*/
public class LoggedUser extends User {
private ArrayList<Patient> patientList = new ArrayList<>();
/**
* @param login
* @param password
*/
public LoggedUser(String login, String password){
super(login, password);
}
/**
* @return the patient list
*/
public ArrayList<Patient> getPatientList() {
return patientList;
}
/**
* Add a patient on the list
* @param patient
*/
public void addPatient (Patient patient) {
patientList.add(patient);
}
public void setPatientList(ArrayList patientList){
this.patientList = patientList;
}
}
|
package com.example.gastos;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.text.method.ScrollingMovementMethod;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class TxtFileActivity extends Activity {
TextView myText;
Button ok;
int data_block = 100;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_txt_file);
myText = (TextView) findViewById(R.id.txtFileView);
myText.setMovementMethod(new ScrollingMovementMethod());
ok = (Button) findViewById(R.id.OkButton);
try {
FileInputStream fis = openFileInput("ListaGastos.txt");
InputStreamReader isr = new InputStreamReader(fis);
int size;
char[] data = new char[data_block];
String final_data = "";
while((size = isr.read(data)) > 0 ){
String read_data = String.copyValueOf(data, 0, size);
final_data += read_data;
data = new char[data_block];
}
myText.setText(final_data);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ok.setOnClickListener(new Button.OnClickListener() {
//Modify Database
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent myIntent = new Intent(v.getContext(), MainActivity.class);
startActivityForResult(myIntent,0);
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.txt_file, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
|
package com.yemyat.zopa.challenge.interest;
public class EffectiveInterestRateFunction implements InterestRateFunction {
@Override
public double getMonthlyInterestRate(double annualInterestRate) {
// References:
// - https://www.experiglot.com/2006/06/07/how-to-convert-from-an-annual-rate-to-an-effective-periodic-rate-javascript-calculator/
// - https://www.engineeringtoolbox.com/effective-nominal-interest-rates-d_1468.html
return Math.pow((1 + annualInterestRate), (1.0 / 12)) - 1;
}
}
|
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class ZoneDateTimeDemo1
{
public static void main(String[] args)
{
Instant instant = Instant.now();
/*
* Parameters:
*
* instant - the instant to create the date-time from, not
* null
*
* zone - the time-zone, not null
*
* Returns:the zoned date-time, not null
*/
ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(instant,ZoneId.systemDefault());
System.out.println(zonedDateTime);
}
}
|
package com.example.texttrafficeapplication.cjass;
import android.support.annotation.IdRes;
import android.view.View;
import android.widget.CompoundButton;
import android.widget.RadioGroup;
/**
* Created by 赵洪斌 on 2017/10/22.
*/
public abstract class CCC implements CompoundButton.OnCheckedChangeListener {
protected abstract void ddddd(int pp, boolean bb);
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
ddddd((Integer) buttonView.getTag(),isChecked);
}
}
|
package day50_inheritance;
/*
Sub class
child class
Derived class
*/
public class Teacher extends Person{
int teacherID;
public void teach(String topic){
System.out.println("Teacher is teaching " +topic);
System.out.println("Teacher name is " +name);
System.out.println("Teacher age is " + age);
System.out.println("Teacher teacher ID is " + teacherID);
}
}
|
package com.tencent.xweb.xwalk;
import com.tencent.xweb.xwalk.h.2;
class h$2$1 implements Runnable {
final /* synthetic */ String vFe;
final /* synthetic */ 2 vFf;
h$2$1(2 2, String str) {
this.vFf = 2;
this.vFe = str;
}
public final void run() {
this.vFf.vFd.fwL.b(this.vFf.vFd.vCX, this.vFe, null);
}
}
|
package com.unsee.tea.biz.services;
import org.apache.ibatis.session.SqlSession;
import com.unsee.gaia.dal.brokers.AbstractBroker;
import com.unsee.gaia.dal.brokers.DefaultBroker;
import com.unsee.gaia.dal.entities.BaseEntity;
import com.unsee.tea.biz.entities.CompanyEntity;
// if need logger remove comment
// import org.apache.log4j.Logger;
/*********************************************************************
* @author: UnSee Corp.
* @version: 1.0
* @date: 2017-02-25 11:26:05
* @entity: TeaTraceService
*********************************************************************/
public class CompanyService extends TeaCommonService {
// if need logger remove comment
// private final static Logger logger = Logger.getLogger(SysGroupsService.class);
private static class SingletonHolder {
private static final CompanyService INSTANCE = new CompanyService();
}
private CompanyService() {
super("CompanyBroker");
}
public static CompanyService getInstance() {
return SingletonHolder.INSTANCE;
}
public CompanyService(String brokerName) {
super(brokerName);
}
@Override
protected void beforeUpdateEntity(SqlSession session, AbstractBroker broker, BaseEntity ent) throws Exception {
DefaultBroker companyBroker = (DefaultBroker) broker;
//companyBroker.removeEntity(ent);
super.beforeUpdateEntity(session, broker, ent);
}
public CompanyEntity getCompanyInfo() throws Exception{
SqlSession session = null;
try{
session = getSessionProvider().getSqlSession();
return (CompanyEntity) session.selectOne("SelectCompanyInfo");
}catch(Exception ex){
throw ex;
}finally{
getSessionProvider().closeSqlSession();
}
}
}
|
/*******************************************************************************
* =============LICENSE_START=========================================================
*
* =================================================================================
* Copyright (c) 2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ============LICENSE_END=========================================================
*
*******************************************************************************/
package org.onap.ccsdk.dashboard.rest;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.json.JSONObject;
import org.onap.ccsdk.dashboard.exceptions.DashboardControllerException;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprint;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprintList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenant;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenantList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployment;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentExt;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentHelm;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEventList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecution;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionRequest;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeIdList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceIdList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyPluginList;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifySecret;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyTenant;
import org.onap.ccsdk.dashboard.model.cloudify.CloudifyTenantList;
import org.onap.ccsdk.dashboard.util.DashboardProperties;
import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
import org.onap.portalsdk.core.objectcache.AbstractCacheManager;
import org.onap.portalsdk.core.web.support.AppUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.client.HttpStatusCodeException;
@org.springframework.stereotype.Service
public class CloudifyRestClientImpl extends RestClientBase implements CloudifyClient {
private static EELFLoggerDelegate logger =
EELFLoggerDelegate.getLogger(CloudifyRestClientImpl.class);
private String baseUrl;
private static final String BLUEPRINTS = "blueprints";
private static final String DEPLOYMENTS = "deployments";
private static final String EXECUTIONS = "executions";
private static final String TENANTS = "tenants";
private static final String NODES = "nodes";
private static final String NODE_INSTANCES = "node-instances";
private static final String UPDATE_DEPLOYMENT = "update-deployment";
private static final String EVENTS = "events";
private static final String SECRETS = "secrets";
private static final String SERVICE_ID = "service-list";
private static final String PLUGINS = "plugins";
/**
* For caching data
*/
private AbstractCacheManager cacheManager;
@Autowired
public void setCacheManager(AbstractCacheManager cacheManager) {
this.cacheManager = cacheManager;
}
public AbstractCacheManager getCacheManager() {
return cacheManager;
}
@PostConstruct
public void init() throws DashboardControllerException {
String webapiUrl = DashboardProperties.getControllerProperty("site.primary",
DashboardProperties.SITE_SUBKEY_CLOUDIFY_URL);
if (webapiUrl == null) {
throw new IllegalArgumentException("Null URL not permitted");
}
String user = DashboardProperties.getControllerProperty("site.primary",
DashboardProperties.SITE_SUBKEY_CLOUDIFY_USERNAME);
String pass = DashboardProperties.getControllerProperty("site.primary",
DashboardProperties.SITE_SUBKEY_CLOUDIFY_PASS);
URL url = null;
try {
url = new URL(webapiUrl);
baseUrl = url.toExternalForm();
} catch (MalformedURLException ex) {
throw new DashboardControllerException("Failed to parse URL", ex);
}
String urlScheme = webapiUrl.split(":")[0];
if (restTemplate == null) {
createRestTemplate(url, user, pass, urlScheme);
}
}
@SuppressWarnings("unchecked")
public List<CloudifyDeploymentHelm> updateHelmInfo(List<CloudifyDeployment> itemList) {
boolean isHelm = false;
boolean helmStatus = false;
List<CloudifyDeploymentHelm> result = new ArrayList<>();
for (CloudifyDeployment srvc : (List<CloudifyDeployment>) itemList) {
try {
isHelm = false;
helmStatus = false;
CloudifyBlueprintList bpList =
this.getBlueprint(srvc.blueprint_id, srvc.tenant_name);
Map<String, Object> bpPlan = bpList.items.get(0).plan;
Map<String, String> workflows = (Map<String, String>) bpPlan.get("workflows");
Map<String, String> pluginInfo =
((List<Map<String, String>>) bpPlan.get("deployment_plugins_to_install"))
.get(0);
if (pluginInfo.get("name").equals("helm-plugin")) {
isHelm = true;
}
if (workflows.containsKey("status")) {
helmStatus = true;
}
CloudifyDeploymentHelm cfyDeplHelm =
new CloudifyDeploymentHelm(srvc.id, isHelm, helmStatus);
result.add(cfyDeplHelm);
} catch (Exception e) {
logger.error(EELFLoggerDelegate.errorLogger, "getBlueprint failed");
CloudifyDeploymentHelm cfyDeplHelm =
new CloudifyDeploymentHelm(srvc.id, false, false);
result.add(cfyDeplHelm);
continue;
}
}
return result;
}
public List<CloudifyDeploymentExt> updateWorkflowStatus(List<CloudifyDeployment> itemList) {
List<CloudifyDeploymentExt> result = new ArrayList<>();
for (CloudifyDeployment srvc : (List<CloudifyDeployment>) itemList) {
try {
// find deployment execution info per item
CloudifyExecutionList execResults =
this.getExecutionsSummary(srvc.id, srvc.tenant_name);
if (execResults.items != null && !execResults.items.isEmpty()) {
CloudifyDeploymentExt cfyDeplExt =
new CloudifyDeploymentExt(srvc.id, srvc.blueprint_id, srvc.tenant_name);
cfyDeplExt.lastExecution = execResults.items.get(0);
result.add(cfyDeplExt);
}
} catch (Exception e) {
logger.error(EELFLoggerDelegate.errorLogger, "getExecutionsSummary failed");
srvc.lastExecution = null;
continue;
}
}
return result;
}
public List<CloudifyDeployedTenant> getDeploymentForBlueprint(final String bpId) {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS}, new String[] {"blueprint_id",
bpId, "_all_tenants", "true", "_include", "id,created_at,updated_at,tenant_name"});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeploymentForBlueprint begin: url {}",
url);
ResponseEntity<CloudifyDeployedTenantList> response = restTemplate.exchange(url,
HttpMethod.GET, null, new ParameterizedTypeReference<CloudifyDeployedTenantList>() {});
return response.getBody().items;
}
public CloudifyDeployment getDeploymentResource(final String id, final String tenant) {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"id", id, "_include",
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name", "_sort",
"-updated_at", "_sort", "-created_at"});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeploymentResource begin: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyDeploymentList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyDeploymentList>() {});
return response.getBody().items.get(0);
}
@Scheduled(fixedRate = 86400000, initialDelay = 15000)
public void cacheTenants() {
logger.debug(EELFLoggerDelegate.debugLogger, "cacheTenants begin");
CloudifyTenantList tenantsList = this.getTenants();
ReadWriteLock lock = new ReentrantReadWriteLock();
lock.writeLock().lock();
getCacheManager().putObject(TENANTS, tenantsList.items);
lock.writeLock().unlock();
logger.debug(EELFLoggerDelegate.debugLogger, "cacheTenants end");
}
@SuppressWarnings("unchecked")
@Scheduled(fixedDelay = 3600000, initialDelay = 360000)
public void cacheDeploymentExecInfo() {
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeploymentExecInfo begin");
ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
List<CloudifyTenant> tenantItems =
(List<CloudifyTenant>) getCacheManager().getObject(TENANTS);
lock.readLock().unlock();
String cfyTen = "";
if (tenantItems != null) {
for (CloudifyTenant item : tenantItems) {
cfyTen = item.name;
lock.readLock().lock();
List<CloudifyDeployment> cfyDeplList = (List<CloudifyDeployment>) getCacheManager()
.getObject(SERVICE_ID + ":" + cfyTen);
lock.readLock().unlock();
if (cfyDeplList != null) {
List<CloudifyDeploymentExt> cfyDeplExecList =
this.updateWorkflowStatus(cfyDeplList);
lock.writeLock().lock();
getCacheManager().putObject(SERVICE_ID + ":" + cfyTen + ":ext",
cfyDeplExecList);
lock.writeLock().unlock();
}
}
}
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeploymentExecInfo end");
}
@SuppressWarnings("unchecked")
@Scheduled(fixedDelay = 3900000, initialDelay = 600000)
public void cacheDeploymentHelmInfo() {
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeploymentHelmInfo begin");
ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
List<CloudifyTenant> tenantItems =
(List<CloudifyTenant>) getCacheManager().getObject(TENANTS);
lock.readLock().unlock();
String cfyTen = "";
if (tenantItems != null) {
for (CloudifyTenant item : tenantItems) {
cfyTen = item.name;
lock.readLock().lock();
List<CloudifyDeployment> cfyDeplList = (List<CloudifyDeployment>) getCacheManager()
.getObject(SERVICE_ID + ":" + cfyTen);
lock.readLock().unlock();
if (cfyDeplList != null) {
List<CloudifyDeploymentHelm> cfyDeplHelmList = this.updateHelmInfo(cfyDeplList);
lock.writeLock().lock();
getCacheManager().putObject(SERVICE_ID + ":" + cfyTen + ":helm",
cfyDeplHelmList);
lock.writeLock().unlock();
}
}
}
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeploymentHelmInfo end");
}
@Scheduled(fixedDelay = 300000, initialDelay = 90000)
public void cacheDeployments() {
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeployments begin");
int pageSize = 500;
ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
List<CloudifyTenant> tenantItems =
(List<CloudifyTenant>) getCacheManager().getObject(TENANTS);
lock.readLock().unlock();
String cfyTen = "default_tenant";
if (tenantItems != null) {
for (CloudifyTenant item : tenantItems) {
cfyTen = item.name;
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"_include",
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name",
"_sort", "-updated_at", "_sort", "-created_at", "_size",
new Integer(pageSize).toString(), "_offset", new Integer(0).toString()});
logger.debug(EELFLoggerDelegate.debugLogger, "cacheDeployments begin: url {}", url);
HttpEntity<String> entity = getTenantHeader(cfyTen);
ResponseEntity<CloudifyDeploymentList> response =
restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
List<CloudifyDeployment> cfyDeplList = new ArrayList<CloudifyDeployment>();
cfyDeplList.addAll(response.getBody().items);
int totalItems = (int) response.getBody().metadata.pagination.total;
int deplPgOffset = 0;
deplPgOffset += pageSize;
while (deplPgOffset < totalItems) {
url = buildUrl(new String[] {baseUrl, DEPLOYMENTS}, new String[] {"_include",
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name",
"_sort", "-updated_at", "_sort", "-created_at", "_size",
new Integer(pageSize).toString(), "_offset",
new Integer(deplPgOffset).toString()});
response = restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
deplPgOffset += pageSize;
cfyDeplList.addAll(response.getBody().items);
}
lock.writeLock().lock();
getCacheManager().putObject(SERVICE_ID + ":" + cfyTen, cfyDeplList);
lock.writeLock().unlock();
}
}
logger.debug(EELFLoggerDelegate.debugLogger,
"cacheDeployments done putting deployment data");
}
@Override
public CloudifyTenantList getTenants() {
String url = buildUrl(new String[] {baseUrl, TENANTS}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "getTenants: url {}", url);
ResponseEntity<CloudifyTenantList> response = restTemplate.exchange(url, HttpMethod.GET,
null, new ParameterizedTypeReference<CloudifyTenantList>() {});
return response.getBody();
}
@Override
public CloudifyEventList getEventlogs(String executionId, String tenant)
throws Exception {
String url =
buildUrl(new String[] {baseUrl, EVENTS}, new String[] {"execution_id", executionId});
logger.debug(EELFLoggerDelegate.debugLogger, "getEventlogs: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyEventList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyEventList>() {});
return response.getBody();
}
@Override
public CloudifyNodeInstanceIdList getNodeInstanceId(String deploymentId, String nodeId,
String tenant) throws Exception {
String url = buildUrl(new String[] {baseUrl, NODE_INSTANCES},
new String[] {"deployment_id", deploymentId, "node_id", nodeId, "_include", "id"});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceId: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeInstanceIdList> response =
restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyNodeInstanceIdList>() {});
return response.getBody();
}
@Override
public CloudifyNodeInstanceList getNodeInstanceDetails(String deploymentId, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, NODE_INSTANCES},
new String[] {"deployment_id", deploymentId});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceDetails: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeInstanceList> response = restTemplate.exchange(url,
HttpMethod.GET, entity, new ParameterizedTypeReference<CloudifyNodeInstanceList>() {});
return response.getBody();
}
@Override
public CloudifyNodeInstanceIdList getNodeInstances(String deploymentId, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, NODE_INSTANCES},
new String[] {"deployment_id", deploymentId, "_include", "id"});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceId: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeInstanceIdList> response =
restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyNodeInstanceIdList>() {});
return response.getBody();
}
@Override
public CloudifyNodeInstanceList getNodeInstanceVersion(String deploymentId, String nodeId,
String tenant) throws Exception {
String url = buildUrl(new String[] {baseUrl, NODE_INSTANCES}, new String[] {"deployment_id",
deploymentId, "node_id", nodeId, "_include", "runtime_properties,id"});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceVersion: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeInstanceList> response = restTemplate.exchange(url,
HttpMethod.GET, entity, new ParameterizedTypeReference<CloudifyNodeInstanceList>() {});
return response.getBody();
}
@Override
public CloudifyNodeInstanceList getNodeInstanceVersion(String bpId, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, NODES},
new String[] {"deployment_id", bpId, "type", "onap.nodes.component", "_include", "id"});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceId: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeIdList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyNodeIdList>() {});
CloudifyNodeIdList result = response.getBody();
String nodeId = result.items.get(0).id;
return getNodeInstanceVersion(bpId, nodeId, tenant);
}
@Override
public CloudifyNodeInstanceIdList getNodeInstanceId(final String bpId, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, NODES},
new String[] {"deployment_id", bpId, "type", "onap.nodes.component", "_include", "id"});
logger.debug(EELFLoggerDelegate.debugLogger, "getNodeInstanceId: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyNodeIdList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyNodeIdList>() {});
CloudifyNodeIdList result = response.getBody();
String nodeId = result.items.get(0).id;
return getNodeInstanceId(bpId, nodeId, tenant);
}
@Override
public CloudifyExecutionList getExecutions(final String deploymentId, final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS},
new String[] {"deployment_id", deploymentId});
logger.debug(EELFLoggerDelegate.debugLogger, "getExecutions: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyExecutionList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyExecutionList>() {});
return response.getBody();
}
@Override
public CloudifyExecutionList getExecutionsSummary(final String deploymentId,
final String tenant) throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS},
new String[] {"deployment_id", deploymentId, "_include",
"deployment_id,id,status,workflow_id,tenant_name,created_at,ended_at", "_sort",
"-created_at"});
logger.debug(EELFLoggerDelegate.debugLogger, "getExecutions: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyExecutionList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyExecutionList>() {});
return response.getBody();
}
@Override
public CloudifyExecutionList getExecutionsSummaryPerTenant(final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS},
new String[] {"_include",
"deployment_id,id,status,workflow_id,tenant_name,created_at,ended_at", "_sort",
"-created_at"});
logger.debug(EELFLoggerDelegate.debugLogger, "getExecutionsSummaryPerTenant: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyExecutionList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyExecutionList>() {});
return response.getBody();
}
public CloudifyExecution getExecutionIdSummary(final String id, final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS, id},
new String[] {"_include",
"deployment_id,id,status,workflow_id,tenant_name,created_at,ended_at", "_sort",
"-created_at"});
logger.debug(EELFLoggerDelegate.debugLogger, "getExecutionIdSummary: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyExecution> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyExecution>() {});
return response.getBody();
}
@Override
public CloudifyExecutionList getInstallExecutionSummary(final String deploymentId,
final String tenant) {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS},
new String[] {"deployment_id", deploymentId, "workflow_id", "install", "_include",
"deployment_id,id,status,workflow_id,tenant_name,created_at"});
logger.debug(EELFLoggerDelegate.debugLogger, "getExecutions: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyExecutionList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyExecutionList>() {});
return response.getBody();
}
@Override
public CloudifyExecution startExecution(CloudifyExecutionRequest execution)
throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "startExecution: url {}", url);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.set("Tenant", execution.tenant);
HttpEntity<CloudifyExecutionRequest> entity =
new HttpEntity<CloudifyExecutionRequest>(execution, headers);
return restTemplate.postForObject(url, entity, CloudifyExecution.class);
}
@Override
public CloudifyExecution cancelExecution(final String executionId,
Map<String, String> parameters, final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, EXECUTIONS, executionId}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "deleteExecution: url {}", url);
JSONObject requestJson = new JSONObject(parameters);
// set headers
HttpHeaders headers = new HttpHeaders();
headers.set("Tenant", tenant);
headers.set("Content-Type", "application/json");
HttpEntity<String> entity = new HttpEntity<String>(requestJson.toString(), headers);
ResponseEntity<CloudifyExecution> response = restTemplate.exchange(url, HttpMethod.POST,
entity, new ParameterizedTypeReference<CloudifyExecution>() {});
return response.getBody();
}
@Override
public CloudifyBlueprintList getBlueprint(final String id, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, BLUEPRINTS}, new String[] {"id", id});
logger.debug(EELFLoggerDelegate.debugLogger, "getBlueprint: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyBlueprintList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyBlueprintList>() {});
return response.getBody();
}
@Override
public byte[] viewBlueprint(String tenant, final String id)
throws Exception {
String url = buildUrl(new String[] {baseUrl, BLUEPRINTS, id, "archive"}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "viewBlueprint: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<byte[]> response =
restTemplate.exchange(url, HttpMethod.GET, entity, byte[].class);
if (response.getStatusCode() == HttpStatus.OK) {
return response.getBody();
}
return null;
}
@Override
public List<CloudifyDeployment> getDeployments(String tenant, int pageSize, int pageOffset,
boolean recurse) {
return this.getDeployments(tenant, pageSize, pageOffset, true, true);
}
@SuppressWarnings("unchecked")
@Override
public List<CloudifyDeployment> getDeployments(String tenant, int pageSize, int pageOffset,
boolean recurse, boolean cache) {
List<CloudifyDeployment> cfyDeplList = null;
if (cache) {
cfyDeplList =
(List<CloudifyDeployment>) getCacheManager().getObject(SERVICE_ID + ":" + tenant);
}
if (cfyDeplList == null || cfyDeplList.isEmpty()) {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS}, new String[] {"_include",
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name", "_sort",
"-updated_at", "_sort", "-created_at", "_size", new Integer(pageSize).toString(),
"_offset", new Integer(pageOffset).toString()});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployments: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyDeploymentList> response =
restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
cfyDeplList = new ArrayList<CloudifyDeployment>();
cfyDeplList.addAll(response.getBody().items);
if (recurse) {
int totalItems = (int) response.getBody().metadata.pagination.total;
int deplPgOffset = 0;
deplPgOffset += pageSize;
while (deplPgOffset < totalItems) {
url = buildUrl(new String[] {baseUrl, DEPLOYMENTS}, new String[] {"_include",
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name",
"_sort", "-updated_at", "_sort", "-created_at", "_size",
new Integer(pageSize).toString(), "_offset",
new Integer(deplPgOffset).toString()});
response = restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
deplPgOffset += pageSize;
cfyDeplList.addAll(response.getBody().items);
}
}
}
return cfyDeplList;
}
public CloudifyDeploymentList getDeployments(String tenant, int pageSize, int pageOffset) {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"_include",
"id,blueprint_id,created_at,updated_at,created_by,description", "_sort",
"-updated_at", "_sort", "-created_at", "_size", new Integer(pageSize).toString(),
"_offset", new Integer(pageOffset).toString()});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployments: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyDeploymentList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyDeploymentList>() {});
return response.getBody();
}
@Override
public List<CloudifyDeployment> getDeploymentsByInputFilter(String inputKey, String inputValue)
throws Exception {
JSONObject inputObject =
new JSONObject().put("inputKey", inputKey).put("inputValue", inputValue);
String filter = new JSONObject().put("input", inputObject).toString();
return getDeploymentsWithFilter(null, filter);
}
@SuppressWarnings("unchecked")
@Override
public List<String> getDeploymentNamesWithFilter(HttpServletRequest request) throws Exception {
List<CloudifyDeployment> itemList = this.getDeploymentsWithFilter(request);
Set<String> svcIdList = new HashSet<String>();
if (itemList != null) {
svcIdList = (Set) itemList.stream().map(x -> ((CloudifyDeployment) x).id)
.collect(Collectors.toSet());
}
List<String> response = new ArrayList<String>();
response.addAll(svcIdList);
return response;
}
@SuppressWarnings("unchecked")
@Override
public List<CloudifyDeployment> getDeploymentsWithFilter(HttpServletRequest request)
throws Exception {
String filters = request.getParameter("filters");
List<CloudifyDeployment> deployments = new ArrayList<CloudifyDeployment>();
if (filters != null) {
deployments = getDeploymentsWithFilter(request, filters);
} else {
List<CloudifyTenant> selectedTenants = new ArrayList<CloudifyTenant>();
selectedTenants = getTenants().items;
List<CloudifyDeployment> itemList = null;
for (CloudifyTenant tenant : selectedTenants) {
itemList = this.getDeployments(tenant.name, 500, 0, true);
deployments.addAll(itemList);
}
// apply user role based auth
Set<String> userApps = null;
Set<String> userRoleSet = null;
try {
HttpSession session = AppUtils.getSession(request);
userApps = (Set<String>) session.getAttribute("authComponents");
userRoleSet = (Set<String>) session.getAttribute("user_roles");
} catch (Exception e) {
// requester is REST API
userRoleSet = (Set<String>) request.getAttribute("userRoles");
userApps = (Set<String>) request.getAttribute("userApps");
}
if (userApps == null) {
userApps = new TreeSet<String>();
}
if (userRoleSet == null) {
userRoleSet = new TreeSet<String>();
}
Predicate<String> adminPred =
p -> p.contains("System_Administrator") || p.contains("Write_Access");
Predicate<String> ecompSuperPred =
p -> p.contains("ECOMPC_WRITE") || p.contains("ECOMPC_READ");
if (userRoleSet.size() > 0) {
if (userRoleSet.stream().noneMatch(adminPred)) {
List<String> myApps = new ArrayList(userApps);
if (userRoleSet.stream().noneMatch(ecompSuperPred)) {
deployments =
(List<CloudifyDeployment>) deployments.stream()
.filter(s -> myApps.stream()
.anyMatch(roleFilter -> ((CloudifyDeployment) s).id
.toLowerCase().startsWith(roleFilter)))
.collect(Collectors.toList());
} else {
Predicate<CloudifyDeployment> appFilter =
p -> p.id.toLowerCase().indexOf("dcae") == -1
|| p.id.toLowerCase().indexOf("d2a") == -1;
deployments = (List<CloudifyDeployment>) deployments.stream()
.filter(appFilter).collect(Collectors.toList());
}
}
}
}
return deployments;
}
@Override
public List<CloudifyDeployment> getDeploymentsWithFilter(HttpServletRequest request,
String filter) throws Exception {
String url = "";
JSONObject filterJson = new JSONObject(filter);
ReadWriteLock lock = new ReentrantReadWriteLock();
// ---------Handle Tenant filter---------//
List<CloudifyTenant> selectedTenants = new ArrayList<CloudifyTenant>();
if (filterJson.has("tenant")) {
String tenantFilterString = "";
Object tenantObject = filterJson.get("tenant");
// Check for logic operators
if (tenantObject instanceof JSONObject) {
JSONObject tenantJsonObject = filterJson.getJSONObject("tenant");
if (tenantJsonObject.has("$not")) {
tenantFilterString = tenantJsonObject.getString("$not");
selectedTenants = tenantFilter(tenantFilterString, true);
} else {
throw new Exception("ERROR: Not a valid logic operator");
}
} else if (tenantObject instanceof String) {
tenantFilterString = filterJson.getString("tenant");
selectedTenants = tenantFilter(tenantFilterString, false);
}
} else {
selectedTenants = getTenants().items;
}
// ---------Get Deployments based on tenants selected---------//
List<CloudifyDeployment> deployments = new ArrayList<CloudifyDeployment>();
List<CloudifyDeployment> itemList = null;
HttpEntity<String> entity;
String tenantFilterStr = "";
int pageSize = 500;
// ---------Handle the _include filter---------//
String include = filterJson.has("_include") ? filterJson.getString("_include") : null;
for (CloudifyTenant tenant : selectedTenants) {
tenantFilterStr = tenant.name;
lock.readLock().lock();
itemList = (List<CloudifyDeployment>) getCacheManager()
.getObject("service-list" + ":" + tenantFilterStr);
lock.readLock().unlock();
if (itemList == null || include != null) {
if (include == null || include.isEmpty()) {
include =
"id,blueprint_id,created_at,updated_at,created_by,description,tenant_name";
}
url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"_include", include, "_sort", "-updated_at", "_sort",
"-created_at", "_size", new Integer(pageSize).toString(), "_offset",
new Integer(0).toString()});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployments: url {}", url);
entity = getTenantHeader(tenant.name);
ResponseEntity<CloudifyDeploymentList> response =
restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
deployments.addAll(response.getBody().items);
int totalItems = (int) response.getBody().metadata.pagination.total;
int deplPgOffset = 0;
deplPgOffset += pageSize;
while (deplPgOffset < totalItems) {
url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"_include", include, "_sort", "-updated_at", "_sort",
"-created_at", "_size", new Integer(pageSize).toString(), "_offset",
new Integer(deplPgOffset).toString()});
response = restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifyDeploymentList>() {});
deplPgOffset += pageSize;
deployments.addAll(response.getBody().items);
}
} else {
deployments.addAll(itemList);
}
}
// apply user role based auth
Set<String> userRoleSet = (Set<String>) request.getAttribute("userRoles");
Set<String> userApps = (Set<String>) request.getAttribute("userApps");
Predicate<String> adminPred =
p -> p.contains("System_Administrator") || p.contains("Write_Access");
Predicate<String> ecompSuperPred =
p -> p.contains("ECOMPC_WRITE") || p.contains("ECOMPC_READ");
if (userRoleSet.stream().noneMatch(adminPred)) {
if (userRoleSet.stream().noneMatch(ecompSuperPred)) {
deployments = (List<CloudifyDeployment>) deployments.stream()
.filter(s -> userApps.stream()
.anyMatch(appFilter -> (((CloudifyDeployment) s).id.toLowerCase()
.indexOf(appFilter) == 0)))
.collect(Collectors.<CloudifyDeployment>toList());
} else {
Predicate<CloudifyDeployment> appFilter =
p -> p.id.toLowerCase().indexOf("dcae") == -1;
deployments = (List<CloudifyDeployment>) deployments.stream().filter(appFilter)
.collect(Collectors.toList());
}
}
List<CloudifyDeployment> filteredDeployments = deployments;
// -------------------ServiceId Filter-------------------//
if (filterJson.has("serviceId")) {
String serviceIdFilterString;
Object serviceIdObject = filterJson.get("serviceId");
// Check for logic operators
if (serviceIdObject instanceof JSONObject) {
JSONObject serviceIdJsonObject = filterJson.getJSONObject("serviceId");
if (serviceIdJsonObject.has("$not")) {
serviceIdFilterString = serviceIdJsonObject.getString("$not");
filteredDeployments =
serviceIdFilter(serviceIdFilterString, filteredDeployments, true);
} else {
throw new Exception("ERROR: Not a valid logic operator");
}
} else if (serviceIdObject instanceof String) {
serviceIdFilterString = filterJson.getString("serviceId");
filteredDeployments =
serviceIdFilter(serviceIdFilterString, filteredDeployments, false);
}
}
// ------------------Handle Input Filter--------------//
if (filterJson.has("input")) {
JSONObject inputFilterObject;
Object inputObject = filterJson.get("input");
// Check for logic operators
if (inputObject instanceof JSONObject) {
JSONObject inputJsonObject = filterJson.getJSONObject("input");
if (inputJsonObject.has("$not")) {
inputFilterObject = inputJsonObject.getJSONObject("$not");
filteredDeployments = inputFilter(inputFilterObject, filteredDeployments, true);
}
// If no operators, pass to filter func
else {
inputFilterObject = inputJsonObject;
filteredDeployments =
inputFilter(inputFilterObject, filteredDeployments, false);
}
}
}
// -------------------Install Status Filter-------------------//
if (filterJson.has("installStatus")) {
String installStatusFilterString;
Object installStatusObject = filterJson.get("installStatus");
// Check for logic operators
if (installStatusObject instanceof JSONObject) {
JSONObject installStatusJsonObject = filterJson.getJSONObject("installStatus");
if (installStatusJsonObject.has("$not")) {
installStatusFilterString = installStatusJsonObject.getString("$not");
filteredDeployments =
installStatusFilter(installStatusFilterString, filteredDeployments, true);
} else {
throw new Exception("ERROR: Not a valid logic operator");
}
} else if (installStatusObject instanceof String) {
installStatusFilterString = filterJson.getString("installStatus");
filteredDeployments =
installStatusFilter(installStatusFilterString, filteredDeployments, false);
}
}
// -------------------isHelm Filter-------------------//
if (filterJson.has("isHelm")) {
String helmFilterString;
Object helmObject = filterJson.get("isHelm");
// Check for logic operators
if (helmObject instanceof JSONObject) {
JSONObject helmJsonObject = filterJson.getJSONObject("isHelm");
if (helmJsonObject.has("$not")) {
helmFilterString = helmJsonObject.getString("$not");
filteredDeployments = helmFilter(helmFilterString, filteredDeployments, true);
} else {
throw new Exception("ERROR: Not a valid logic operator");
}
} else if (helmObject instanceof String) {
helmFilterString = filterJson.getString("isHelm");
filteredDeployments = helmFilter(helmFilterString, filteredDeployments, false);
}
}
return filteredDeployments;
}
/*
* Helper function to handle the tenant filter
*/
private List<CloudifyTenant> tenantFilter(String filterString, boolean isNot) throws Exception {
CloudifyTenantList availableTenants = getTenants();
List<CloudifyTenant> selectedTenants = new ArrayList<CloudifyTenant>();
// If using tenant filter, verify its valid tenant name
if (filterString != null && !filterString.isEmpty()) {
for (CloudifyTenant tenant : availableTenants.items) {
if (!isNot && tenant.name.equals(filterString)) {
selectedTenants.add(tenant);
} else if (isNot && !tenant.name.equals(filterString)) {
selectedTenants.add(tenant);
}
}
if (selectedTenants.isEmpty()) {
throw new Exception(
"ERROR: Tenant filter was used but resulted in no selected tenants");
}
}
// If no proper tenants given
else {
throw new Exception("ERROR: Tenant filter was used but no tenants were given");
}
return selectedTenants;
}
/*
* Helper function to filter deployments by serviceId
*/
private List<CloudifyDeployment> serviceIdFilter(String filterString,
List<CloudifyDeployment> deployments, boolean isNot) throws Exception {
List<CloudifyDeployment> newFilteredDeployments = new ArrayList<CloudifyDeployment>();
if (filterString != null && !filterString.isEmpty()) {
for (CloudifyDeployment dep : deployments) {
if (!isNot && dep.id.contains(filterString))
newFilteredDeployments.add(dep);
else if (isNot && !dep.id.contains(filterString))
newFilteredDeployments.add(dep);
}
} else {
throw new Exception(
"ERROR: Service ID filter was used but a valid serviceId String was not provided");
}
return newFilteredDeployments;
}
/*
* Helper function to filter deployments by input
*/
private List<CloudifyDeployment> inputFilter(JSONObject filterJson,
List<CloudifyDeployment> deployments, boolean isNot) throws Exception {
List<CloudifyDeployment> newFilteredDeployments = new ArrayList<CloudifyDeployment>();
if (filterJson != null && filterJson.has("inputKey") && filterJson.has("inputValue")
&& !filterJson.isNull("inputKey") && !filterJson.isNull("inputValue")) {
String inputKey = filterJson.getString("inputKey");
String inputValue = filterJson.getString("inputValue");
/// For now, only allow the use of aaf_username and dcaeTargetType input key
if (!inputKey.equals("aaf_username") && !inputKey.equals("dcae_target_type"))
throw new Exception("ERROR: This input key is NOT supported");
// For each deployment, get the input keys that contain <inputKey>
// then check their value to see if it contains the desired <inputValue>
for (CloudifyDeployment dep : deployments) {
if (dep.inputs == null)
throw new Exception(
"ERROR: Deployment inputs not found, 'inputs' must be in the include filter for input filtering");
Set<String> filteredDepInputKeys = dep.inputs.keySet().stream()
.filter(s -> s.contains(inputKey)).collect(Collectors.toSet());
for (String filteredKey : filteredDepInputKeys) {
String value = dep.inputs.get(filteredKey).toString();
if (!isNot && value.equals(inputValue)) {
newFilteredDeployments.add(dep);
break;
} else if (isNot && !value.equals(inputValue)) {
newFilteredDeployments.add(dep);
break;
}
}
}
} else { // If filter used but no valid KV found
throw new Exception(
"ERROR: Input filter was used but a valid inputKey and inputValue was not provided");
}
return newFilteredDeployments;
}
/*
* Helper function to filter deployments by install status
*/
private List<CloudifyDeployment> installStatusFilter(String filterString,
List<CloudifyDeployment> deployments, boolean isNot) throws Exception {
List<CloudifyDeployment> newFilteredDeployments = new ArrayList<CloudifyDeployment>();
if (filterString != null && !filterString.isEmpty()) {
// For each deployment, get execution status and compare to filter
for (CloudifyDeployment dep : deployments) {
List<CloudifyExecution> executions =
getInstallExecutionSummary(dep.id, dep.tenant_name).items;
if (executions.size() > 0) {
String status = executions.get(0).status;
if (!isNot && status.equals(filterString)) {
newFilteredDeployments.add(dep);
} else if (isNot && !status.equals(filterString)) {
newFilteredDeployments.add(dep);
}
}
}
} else { // If using filter but invalid install status given
throw new Exception(
"ERROR: Install Status filter was used but a valid installStatus String was not provided");
}
return newFilteredDeployments;
}
/*
* Helper function to filter by isHelm
*/
private List<CloudifyDeployment> helmFilter(String filterJson,
List<CloudifyDeployment> deployments, boolean isNot)
throws HttpStatusCodeException, Exception {
List<CloudifyDeployment> newFilteredDeployments = new ArrayList<CloudifyDeployment>();
if (filterJson != null && !filterJson.isEmpty()) {
// For each deployment, get blueprint and see if it has helm plugin and compare to
// filter
for (CloudifyDeployment dep : deployments) {
CloudifyBlueprintList bpList = getBlueprint(dep.blueprint_id, dep.tenant_name);
Map<String, Object> bpPlan = bpList.items.get(0).plan;
Map<String, String> workflows = (Map<String, String>) bpPlan.get("workflows");
Map<String, String> pluginInfo =
((List<Map<String, String>>) bpPlan.get("deployment_plugins_to_install"))
.get(0);
if (pluginInfo.get("name").equals("helm-plugin")) {
if (!isNot && (filterJson.equals("true") || filterJson.equals("True")
|| filterJson.equals("TRUE")))
newFilteredDeployments.add(dep);
else if (isNot && (filterJson.equals("false") || filterJson.equals("False")
|| filterJson.equals("FALSE")))
newFilteredDeployments.add(dep);
} else if (!isNot && (filterJson.equals("false") || filterJson.equals("False")
|| filterJson.equals("FALSE")))
newFilteredDeployments.add(dep);
else if (isNot && (filterJson.equals("true") || filterJson.equals("True")
|| filterJson.equals("TRUE")))
newFilteredDeployments.add(dep);
}
} else { // If not using filter, just return original deployments
newFilteredDeployments = deployments;
}
return newFilteredDeployments;
}
@Override
public CloudifyDeploymentList getDeployment(final String id)
throws HttpStatusCodeException, Exception {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"id", id, "_all_tenants", "true"});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployment: url {}", url);
ResponseEntity<CloudifyDeploymentList> response = restTemplate.exchange(url, HttpMethod.GET,
null, new ParameterizedTypeReference<CloudifyDeploymentList>() {});
return response.getBody();
}
@Override
public CloudifyDeploymentList getDeployment(final String id, final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS}, new String[] {"id", id});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployment: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyDeploymentList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyDeploymentList>() {});
return response.getBody();
}
@Override
public CloudifyDeploymentList getDeploymentInputs(final String id, final String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, DEPLOYMENTS},
new String[] {"id", id, "_include", "inputs"});
logger.debug(EELFLoggerDelegate.debugLogger, "getDeployment: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifyDeploymentList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyDeploymentList>() {});
return response.getBody();
}
/**
* Get a cloudify secret
*
* @return CloudifySecret
*/
@Override
public CloudifySecret getSecret(String secretName, String tenant) {
String url = buildUrl(new String[] {baseUrl, SECRETS, secretName}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "getSecrets: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
ResponseEntity<CloudifySecret> response = restTemplate.exchange(url, HttpMethod.GET, entity,
new ParameterizedTypeReference<CloudifySecret>() {});
return response.getBody();
}
/**
* Get the list of cloudify plugins
*
* @return List<CloudifyPlugin>
*/
public CloudifyPluginList getPlugins() throws Exception {
String url = buildUrl(new String[] {baseUrl, PLUGINS}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "getPlugins: url {}", url);
HttpEntity<String> entity = getTenantHeader("default_tenant");
ResponseEntity<CloudifyPluginList> response = restTemplate.exchange(url, HttpMethod.GET,
entity, new ParameterizedTypeReference<CloudifyPluginList>() {});
CloudifyPluginList result = response.getBody();
return result;
}
@Override
public void deleteBlueprint(String bpName, String tenant)
throws Exception {
String url = buildUrl(new String[] {baseUrl, BLUEPRINTS, bpName}, null);
logger.debug(EELFLoggerDelegate.debugLogger, "deleteBlueprint: url {}", url);
HttpEntity<String> entity = getTenantHeader(tenant);
restTemplate.exchange(url, HttpMethod.DELETE, entity,
new ParameterizedTypeReference<CloudifyBlueprint>() {});
}
}
|
/*
*
*/
// Imports and Packages
package TLTTC;
import java.util.*;
public class ControllerList
{
CTCController _controller;
ControllerList (CTCController controller)
{
_controller = controller;
}
}
|
package sortdemo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
//class SortByBalanceAsc implements Comparator<Customer>{
//
// @Override
// public int compare(Customer o1, Customer o2) {
// // TODO Auto-generated method stub
// return ((Double)o1.getBalance()).compareTo(o2.getBalance());
// }
//
//}
//class SortByBalanceDesc implements Comparator<Customer>{
//
// @Override
// public int compare(Customer o1, Customer o2) {
// // TODO Auto-generated method stub
// return ((Double)o2.getBalance()).compareTo(o1.getBalance());
// }
//
//}
class Customer implements Comparable<Customer>{
private int id ;
private String name;
private double balance;
@Override
protected void finalize() throws Throwable {
System.out.println("Good Bye.. "+this);
}
@Override
public int compareTo(Customer customer)
{
//return ((Double)this.balance).compareTo(customer.balance);
//return this.name.compareTo(customer.name);
return this.name.compareToIgnoreCase(customer.name);
}
Customer(int id, String name, double balance){
this.id = id;
this.name = name;
this.balance = balance;
System.out.println("Cons Call");
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
@Override
public String toString() {
return "Id "+id+" Name "+name+" Balance is "+balance+"\n";
}
}
public class Demo1 {
public static void main(String[] args) {
ArrayList<Customer> customers = new ArrayList<>();
customers.add(new Customer(1001, "Ram",1119999));
customers.add(new Customer(1002, "Shyam",29999));
customers.add(new Customer(1004, "anil",59999));
customers.add(new Customer(1002, "ajay",99999));
//Collections.sort(customers);
//Collections.sort(customers, new SortByBalanceAsc());
//Collections.sort(customers, new SortByBalanceDesc());
// Collections.sort(customers
// ,(o1, o2)->o1.getName()
// .compareTo(o2.getName()));
Collections.sort(customers,(o1, o2)->
((Double)o1.getBalance()).compareTo(o2.getBalance()));
System.out.println(customers);
// ArrayList<String> l= new ArrayList<>();
// l.add("ram");
// l.add("anil");
// l.add("shyam");
// System.out.println(l);
// Collections.sort(l);
// System.out.println(l);
}
}
|
package com.yfancy.web.weixin.controller;
import com.yfancy.common.base.Result;
import com.yfancy.common.base.init.Weixin_Init_Param;
import com.yfancy.common.base.url.WEB_WEIXIN_URL_Mapping;
import com.yfancy.common.base.util.HttpClientUtil;
import com.yfancy.web.weixin.config.WeixinConfig;
import com.yfancy.web.weixin.helper.WeixinHelper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* 微信模版类消息处理
*/
@RestController
@Slf4j
public class WxTempleteController {
@Autowired
private WeixinHelper weixinHelper;
@RequestMapping(value = WEB_WEIXIN_URL_Mapping.weixin_send_templete,method = RequestMethod.POST)
public Result sendTempleteMsg(@RequestParam("userId") String userId,@RequestParam("templeteType") int templeteType){
log.info("[WxTempleteController][sendTempleteMsg],发送模版信息，开始");
String templeteContent = weixinHelper.createWeixinTempleteMsg(userId,templeteType);
Result result = weixinHelper.sendWeixinTempleteMsg(templeteContent);
return result;
}
}
|
package com.codemine.talk2me;
import android.app.ActionBar;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.Intent;
import android.graphics.Color;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Handler;
import android.os.Message;
import android.provider.CalendarContract;
import android.support.v4.app.FragmentActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
import com.codemine.talk2me.bluetoothchat.BluetoothChatService;
import com.codemine.talk2me.bluetoothchat.Constants;
import java.util.ArrayList;
import java.util.HashMap;
public class BluetoothChatActivity extends AppCompatActivity {
private static final int REQUEST_CONNECT_DEVICE_SECURE = 1;
private static final int REQUEST_CONNECT_DEVICE_INSECURE = 2;
private static final int REQUEST_ENABLE_BT = 3;
ArrayList<ChattingInfo> chattingInfos = new ArrayList<>();
private BluetoothChatService mChatService;
private String mConnectedDeviceName;
private BluetoothAdapter mBtAdapter;
private ChattingAdapter chattingAdapter;
private ListView chatList;
private EditText inputMsgText;
private Button sendMsgButton;
private TextView backText;
private TextView chattingWith;
private TextView jumpToVoiceText;
private TextView bloothConnect;
private BluetoothDevice device;
Button changeModeButton;
ChatMode chatMode = ChatMode.TEXT;
Button inputVoiceButton;
int frequency = 10000;
int channelConfiguration = AudioFormat.CHANNEL_IN_DEFAULT;
int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;
int bufferSize = 128*1024;
AudioTrack audioTrack = new AudioTrack(
AudioManager.STREAM_MUSIC,
frequency,
channelConfiguration,
audioEncoding,
bufferSize*2,
AudioTrack.MODE_STREAM
);
AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,
frequency, channelConfiguration,
audioEncoding, bufferSize);
boolean isStop = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getSupportActionBar() != null)
getSupportActionBar().hide();
setContentView(R.layout.activity_chat);
mBtAdapter = BluetoothAdapter.getDefaultAdapter();
mChatService = new BluetoothChatService(mHandler);
Thread t = new Thread(mChatService);
t.start();
mChatService.start();
String address = getIntent().getStringExtra("device address");
// Get the BluetoothDevice object
device = mChatService.mAdapter.getRemoteDevice(address);
HashMap<String, Object> param = new HashMap<String, Object>();
param.put("mHandler", mHandler);
param.put("device", device);
param.put("secure", true);
Task task = new Task(Task.TASK_CONECT_DEVICE, param);
mChatService.newTask(task);
// Attempt to connect to the device
((Data) getApplication()).setmChatService(mChatService);
chatList = (ListView) findViewById(R.id.chattingListView);
inputMsgText = (EditText) findViewById(R.id.inputMsgText);
sendMsgButton = (Button) findViewById(R.id.sendMsgButton);
bloothConnect = (TextView) findViewById(R.id.bluetoothConnect);
backText = (TextView) findViewById(R.id.back_text);
chattingWith = (TextView) findViewById(R.id.chattingWith);
jumpToVoiceText = (TextView) findViewById(R.id.jump_to_voice_text);
chattingWith.setText(getIntent().getStringExtra("device name"));
mConnectedDeviceName = getIntent().getStringExtra("device name");
//点击返回主界面
backText.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
inputVoiceButton = (Button) findViewById(R.id.inputVoiceButton);
changeModeButton = (Button) findViewById(R.id.changeModButton);//改变模式的按钮
changeModeButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(chatMode == ChatMode.VOICE) {
chatMode = ChatMode.TEXT;
inputVoiceButton.setVisibility(View.GONE);
inputMsgText.setVisibility(View.VISIBLE);
sendMsgButton.setVisibility(View.VISIBLE);
changeModeButton.setText("语音");
inputMsgText.setHint("请输入......");
}
else {
chatMode = ChatMode.VOICE;
changeModeButton.setText("文字");
inputVoiceButton.setVisibility(View.VISIBLE);
inputVoiceButton.setBackgroundResource(R.color.white);
inputMsgText.setVisibility(View.GONE);
sendMsgButton.setVisibility(View.GONE);
// inputMsgText.setEnabled(false);
// inputMsgText.setText("");
// inputMsgText.setHint("按住说话");
// inputMsgText.setTextColor(Color.parseColor("#EBEBEB"));
// changeModeButton.setText("文字");
}
}
});
inputVoiceButton.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
inputVoiceButton.setBackgroundResource(R.color.deepGray);
startSend();
break;
case MotionEvent.ACTION_UP:
inputVoiceButton.setBackgroundResource(R.color.white);
stopSend();
break;
default:
break;
}
return true;
}
});
//点击跳转到语音通话界面
// jumpToVoiceText.setOnClickListener(new View.OnClickListener() {
// @Override
// public void onClick(View view) {
// Intent intent = new Intent();
// intent.putExtra("contactName", getIntent().getStringExtra("device name"));
// intent.putExtra("ipAddr", getIntent().getStringExtra("device address"));
// intent.setClass(BluetoothChatActivity.this, BluetoothVoiceActivity.class);
// startActivity(intent);
// }
// });
bloothConnect.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
HashMap<String, Object> param = new HashMap<String, Object>();
param.put("mHandler", mHandler);
param.put("device", device);
param.put("secure", true);
Task task = new Task(Task.TASK_CONECT_DEVICE, param);
mChatService.newTask(task);
}
});
ChattingAdapter chattingAdapter = new ChattingAdapter(BluetoothChatActivity.this, R.layout.chatting_item, chattingInfos);
chatList.setAdapter(chattingAdapter);
chatList.setSelection(chattingInfos.size() - 1);
//点击发送信息
inputMsgText.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
if (!inputMsgText.getText().toString().equals(""))
sendMsgButton.setBackgroundColor(Color.parseColor("#FFC125"));
else
sendMsgButton.setBackgroundColor(Color.parseColor("#EBEBEB"));
}
@Override
public void afterTextChanged(Editable editable) {
}
});
chattingAdapter = new ChattingAdapter(BluetoothChatActivity.this, R.layout.chatting_item, chattingInfos);
chatList.setAdapter(chattingAdapter);
sendMsgButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (!inputMsgText.getText().toString().equals("")) {
String message = inputMsgText.getText().toString();
sendMessage(message);
}
inputMsgText.getText().clear();
}
});
}
public void writebyte(byte[] buffer, String message){
System.out.println(message);
for(byte b: buffer)
System.out.print(b);
System.out.println("23333333333");
}
private void startSend(){
new Thread(new Runnable() {
@Override
public void run() {
new AudioRecord(MediaRecorder.AudioSource.MIC,
frequency, channelConfiguration,
audioEncoding, bufferSize);
audioRecord.startRecording();
byte[] record_buffer = new byte[bufferSize];
while(!isStop){
audioRecord.read(record_buffer, 0, bufferSize);
writebyte(record_buffer,"send");
sendMessage(record_buffer);
}
audioRecord.stop();
isStop = false;
}
}).start();
}
private void sendMessage(byte[] message) {
// Check that we're actually connected before trying anything
if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {
//Toast.makeText(BluetoothVoiceActivity.this, "not connected!", Toast.LENGTH_SHORT).show();
return;
}
if (message.length > 0) {
// Get the message bytes and tell the BluetoothChatService to write
HashMap<Integer, byte[]> param = new HashMap<Integer, byte[]>();
param.put(BluetoothChatService.STATE_SEND_MESSAGE, message);
Task task = new Task(Task.TASK_SEND_MESSAGE, param);
BluetoothChatService.newTask(task);
}
}
private void stopSend(){
isStop = true;
}
@Override
protected void onStart() {
super.onStart();
mChatService.setmHandler(mHandler);
}
/**
* Sends a message.
*
* @param message A string of text to send.
*/
private void sendMessage(String message) {
// Check that we're actually connected before trying anything
if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {
Toast.makeText(BluetoothChatActivity.this, "not connected!", Toast.LENGTH_SHORT).show();
return;
}
// Check that there's actually something to send
if (message.length() > 0) {
// Get the message bytes and tell the BluetoothChatService to write
byte[] send = message.getBytes();
HashMap<Integer, byte[]> param = new HashMap<Integer, byte[]>();
param.put(BluetoothChatService.STATE_SEND_MESSAGE, send);
Task task = new Task(Task.TASK_SEND_MESSAGE, param);
BluetoothChatService.newTask(task);
}
}
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MESSAGE_STATE_CHANGE:
// switch (msg.arg1) {
// case BluetoothChatService.STATE_CONNECTED:
// setStatus(getString(R.string.title_connected_to, mConnectedDeviceName));
// chattingAdapter.clear();
// break;
// case BluetoothChatService.STATE_CONNECTING:
// setStatus(R.string.title_connecting);
// break;
// case BluetoothChatService.STATE_LISTEN:
// case BluetoothChatService.STATE_NONE:
// setStatus(R.string.title_not_connected);
// break;
// }
break;
case Constants.MESSAGE_WRITE:{
if(chatMode==ChatMode.TEXT){
byte[] writeBuf = (byte[]) msg.obj;
// construct a string from the buffer
String writeMessage = new String(writeBuf);
chattingInfos.add(new ChattingInfo(R.drawable.head, writeMessage, MsgType.OWN, ""));
chatList.setSelection(chattingInfos.size() - 1);
}else{
// byte[] readBuf = (byte[]) msg.obj;
// writebyte(readBuf,"read");
// construct a string from the valid bytes in the buffer
// audioTrack.play();
// audioTrack.write(readBuf,0,bufferSize);
// audioTrack.stop();
chattingInfos.add(new ChattingInfo(R.drawable.head, "语音发送成功", MsgType.OWN, ""));
chatList.setSelection(chattingInfos.size() - 1);
}
break;
}
case Constants.MESSAGE_READ:{
System.out.println("read state");
if(chatMode==ChatMode.VOICE){
byte[] readBuf = (byte[]) msg.obj;
// construct a string from the valid bytes in the buffer
audioTrack.play();
audioTrack.write(readBuf,0,bufferSize);
audioTrack.stop();
}else{
byte[] readBuf = (byte[]) msg.obj;
// construct a string from the valid bytes in the buffer
String readMessage = new String(readBuf, 0, msg.arg1);
chattingInfos.add(new ChattingInfo(R.drawable.head, readMessage, MsgType.OTHER, ""));
chatList.setSelection(chattingInfos.size() - 1);
}
break;
}
case Constants.MESSAGE_DEVICE_NAME:
// save the connected device's name
mConnectedDeviceName = msg.getData().getString(Constants.DEVICE_NAME);
Toast.makeText(BluetoothChatActivity.this, "Connected to "
+ mConnectedDeviceName, Toast.LENGTH_SHORT).show();
break;
case Constants.MESSAGE_TOAST:
Toast.makeText(BluetoothChatActivity.this, msg.getData().getString(Constants.TOAST),
Toast.LENGTH_SHORT).show();
break;
}
}
};
}
|
package com.vajra.TestClass;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.support.ui.Select;
import org.testng.annotations.Test;
import com.vajra.pageobjects.AddCustomerSales;
import com.vajra.pageobjects.CreateOrderPageObject;
public class TC_CreateCustomer_003 extends BaseClasss {
@Test(priority = 1)
public void navigateToCustomerPage() {
TC_AllLogin_001 tc= new TC_AllLogin_001();
tc.Login_TestCase_SE();
CreateOrderPageObject cop= new CreateOrderPageObject(driver);
cop.ClickOnHomeCreateDocument();
cop.ClickOnSearchCustomer();
}
@Test(priority = 2)
public void EnterCustomerDetails() {
AddCustomerSales acs= new AddCustomerSales(driver);
acs.ClickOnCreateCustomerButton();
acs.SelectCustomerTitle();
acs.EnterCustomerFirstName();
acs.EnterCustomerLastName();
acs.SelectCustomerGender();
acs.EnterCustomerAddressOne();
acs.EnterCustomerAddressTwo();
acs.EnterCustomerAddressThree();
acs.EnterCustomerPANNumber();
acs.EnterCustomerMobileNumberOne();
acs.EnterCustomerMobileNumberTwo();
acs.EnterCustomerLandLineHomeNumber();
acs.EnterCustomerCustomerLandLineOffice();
acs.SelectCustomerCountry();
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0,1000)");
acs.SelectCustomerState();
acs.SelectCustomerCity();
acs.EnterCustomerEmailID();
acs.EnterCustomerPINCode();
acs.EnterCustomerGSTNumber();
acs.EnterCustomerAdharCardNumber();
acs.ClickOnAddCustomerButton();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
acs.VerifyCreatedCustomer();
}
}
|
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
public class FortuneCookie implements ActionListener {
private JFrame frame;
private JPanel panel;
private JButton button;
public static void main(String[] args) {
FortuneCookie cookie = new FortuneCookie();
cookie.showButton();
}
public FortuneCookie() {
frame = new JFrame();
frame.setSize(300, 100);
panel = new JPanel();
frame.add(panel);
button = new JButton();
button.setText("WOOHOO!");
panel.add(button);
button.addActionListener(this);
}
public void showButton() {
frame.setVisible(true);
}
public void showFortune() {
String message;
switch (new Random().nextInt(5)) {
case 0:
message = "You will make a lot of money.";
break;
case 1:
message = "You will have an amazing GPA.";
break;
case 2:
message = "Love is at your doorstep.";
break;
case 3:
message = "Your friends have great respect for you.";
break;
default:
message = "Help, I'm being forced to make insecure people feel better about themselves by making fake fortunes ):";
break;
}
JOptionPane.showMessageDialog(frame, message);
}
@Override
public void actionPerformed(ActionEvent event) {
if (event.getSource().equals(button)) {
showFortune();
}
}
}
|
package com.chanpyaeaung.moviez.view.fragment;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.app.AlertDialog;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.Toolbar;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.chanpyaeaung.moviez.R;
import com.chanpyaeaung.moviez.api.ServiceGenerator;
import com.chanpyaeaung.moviez.helpers.Keys;
import com.chanpyaeaung.moviez.model.detail.MovieDetail;
import com.chanpyaeaung.moviez.model.movie.MovieModel;
import com.chanpyaeaung.moviez.model.movie.Result;
import com.chanpyaeaung.moviez.view.MovieListView;
import com.chanpyaeaung.moviez.view.activity.MainActivity;
import com.chanpyaeaung.moviez.view.adapter.MovieListAdapter;
import com.pnikosis.materialishprogress.ProgressWheel;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
/**
* Created by Chan Pyae Aung on 4/3/17.
*/
public class MoviesListFragment extends Fragment implements MovieListView {
@BindView(R.id.recycler_view_movies)
RecyclerView recyclerView;
@BindView(R.id.progressBar)
ProgressWheel progressWheel;
@BindView(R.id.error)
TextView error;
@BindView(R.id.toolbar)
Toolbar toolbar;
@BindView(R.id.swipeRefreshLayout)
SwipeRefreshLayout swipeRefreshLayout;
private List<MovieModel> movielist;
final CharSequence[] sortBy = { " Release Date ", " Popularity" };
private int page = 1;
private boolean isMoreResult = false, isLoading = false;
private int type = 0;
AlertDialog mDialog;
private GridLayoutManager mLayoutManager;
private MovieListAdapter movieListAdapter;
public MoviesListFragment() {
// Required empty public constructor
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
}
@Override
public void onResume() {
super.onResume();
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setHasOptionsMenu(true);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View fragmentView = inflater.inflate(R.layout.fragment_movies_list, container, false);
ButterKnife.setDebug(true);
ButterKnife.bind(this, fragmentView);
((MainActivity)getActivity()).setSupportActionBar(toolbar);
toolbar.setOnMenuItemClickListener(new Toolbar.OnMenuItemClickListener() {
@Override
public boolean onMenuItemClick(MenuItem item) {
switch (item.getItemId()) {
case R.id.action_sort:
showSortDialog();
return true;
default:
return true;
}
}
});
swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
page = 1;
movielist = null;
movieListAdapter.setMovieModels(new ArrayList<MovieModel>());
getMoviesByType();
}
});
return fragmentView;
}
@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initUI();
getMoviesByType();
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
inflater.inflate(R.menu.menu_main, menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.action_sort:
showSortDialog();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
private void getMoviesByType() {
if(type == 0) {
getMoviesByReleaseDate();
} else {
getMovies();
}
}
private void showSortDialog() {
AlertDialog.Builder builder =
new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogStyle);
builder.setTitle("Sort movies by");
builder.setSingleChoiceItems(sortBy, type, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int item) {
type = item;
page = 1;
recyclerView.scrollToPosition(0);
movielist = null;
movieListAdapter.setMovieModels(new ArrayList<MovieModel>());
if (item == 0) {
getMoviesByReleaseDate();
} else {
getMovies();
}
mDialog.dismiss();
}
});
mDialog = builder.create();
mDialog.show();
}
@Override
public void renderMovieList(List<MovieModel> movieModels) {
if(movielist == null) {
movielist = movieModels;
movieListAdapter.setMovieModels(movielist);
} else {
movieListAdapter.addMore(movieModels);
}
}
@Override
public void showLoading() {
isLoading = true;
if (movielist == null) {
progressWheel.setVisibility(View.VISIBLE);
recyclerView.setVisibility(View.GONE);
}
error.setVisibility(View.GONE);
}
@Override
public void hideLoading() {
isLoading = false;
recyclerView.setVisibility(View.VISIBLE);
error.setVisibility(View.GONE);
progressWheel.setVisibility(View.GONE);
}
@Override
public void showError(String message) {
isLoading = false;
isMoreResult = false;
error.setVisibility(View.VISIBLE);
recyclerView.setVisibility(View.GONE);
progressWheel.setVisibility(View.GONE);
error.setText(message);
}
@Override
public Context context() {
return getActivity();
}
private void initUI() {
mLayoutManager = new GridLayoutManager(getActivity(), 3);
recyclerView.setLayoutManager(mLayoutManager);
recyclerView.setHasFixedSize(true);
movieListAdapter = new MovieListAdapter();
recyclerView.setAdapter(movieListAdapter);
recyclerView.setVisibility(View.GONE);
recyclerView.setOnScrollListener(new ScrollListener());
movieListAdapter.setClickListener(new MovieListAdapter.ClickListener() {
@Override
public void onItemClick(View view, int position) {
setHasOptionsMenu(false);
MovieDetailFragment frag = new MovieDetailFragment();
frag.setMovieId(movieListAdapter.getItem(position).getId());
((MainActivity)getActivity()).setFragment(frag);
}
});
}
private void getMovies() {
ServiceGenerator.getMovieService().getMovies(page)
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Result>() {
@Override
public void onSubscribe(Disposable d) {
showLoading();
}
@Override
public void onNext(Result result) {
if(swipeRefreshLayout.isRefreshing()) {
swipeRefreshLayout.setRefreshing(false);
}
if(page < result.getTotalPages()) {
isMoreResult = true;
} else {
isMoreResult = false;
}
renderMovieList(result.getResults());
}
@Override
public void onError(Throwable e) {
showError("Something went wrong caused by " + e.getLocalizedMessage());
}
@Override
public void onComplete() {
hideLoading();
}
});
}
private void getMoviesByReleaseDate() {
Date now = new Date();
String today = new SimpleDateFormat("yyyy-MM-dd").format(now);
ServiceGenerator.getMovieService().getMoviesWithPrimaryReleaseDate(today, Keys.RELEASE_DATE_DESC, page)
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Result>() {
@Override
public void onSubscribe(Disposable d) {
showLoading();
}
@Override
public void onNext(Result result) {
if(swipeRefreshLayout.isRefreshing()) {
swipeRefreshLayout.setRefreshing(false);
}
if(page < result.getTotalPages()) {
isMoreResult = true;
} else {
isMoreResult = false;
}
renderMovieList(result.getResults());
}
@Override
public void onError(Throwable e) {
showError("Something went wrong caused by " + e.getLocalizedMessage());
}
@Override
public void onComplete() {
hideLoading();
}
});
}
private class ScrollListener extends RecyclerView.OnScrollListener {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
if(isMoreResult && !isLoading) {
int numberofVisibleItems = recyclerView.getChildCount();
int firstVisibleItem = mLayoutManager.findFirstVisibleItemPosition();
if(numberofVisibleItems + firstVisibleItem >= movieListAdapter.getItemCount()) {
page++;
getMoviesByType();
}
}
}
}
}
|
package br.senai.sp.informatica.mobileb.aulas.ex04;
import br.senai.sp.informatica.mobileb.lib.Util;
public class Ex0401 {
public static void main(String[] args) {
double nota = Util.leReal("Informe a nota: ");
nota += Util.leReal("Informe a nota: ");
nota += Util.leReal("Informe a nota: ");
nota += Util.leReal("Informe a nota: ");
nota = nota / 4;
if (nota >= 7) {
Util.escreva(nota, "\n", "Aprovado");
} else {
Util.escreva(nota, "\n", "Reprovado");
}
}
}
|
package accessories;
import interfaces.ISellable;
public class Accessory extends Product implements ISellable {
private String partName;
private String brand;
private String partFor;
private String type;
private double buyingPrice;
private double sellingPrice;
public Accessory (String partName, String brand, String partFor, String type, double buyingPrice, double sellingPrice) {
this.partName = partName;
this.brand = brand;
this.partFor = partFor;
this.type = type;
this.buyingPrice = buyingPrice;
this.sellingPrice = sellingPrice;
}
public String getPartName() {
return this.partName;
}
public String getPartFor() {
return this.partFor;
}
public String getBrand() {
return this.brand;
}
public String getType() {
return this.type;
}
public double getBuyingPrice() {
return this.buyingPrice;
}
public double getSellingPrice() {
return this.sellingPrice;
}
public double markup() {
double margin = this.getSellingPrice() - this.getBuyingPrice();
double markup = (margin / this.getBuyingPrice()) * 100;
double markupPercentage = Math.round(markup * 100.0) / 100.0;
return markupPercentage;
}
public double calculateMarkup() {
return markup();
}
}
|
package servlets;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Type;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import beans.Circuit;
import beans.DynamicVariable;
import beans.StaticVariable;
import beans.Variable;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import dao.CircuitDao;
import dao.DaoFactory;
import dao.TransistorDao;
/**
* Servlet implementation class Variables
*/
@WebServlet("/Variables")
public class Variables extends HttpServlet {
private static final long serialVersionUID = 1L;
private LinkedList<Variable> variables;
Circuit circuit;
private CircuitDao circuitDao;
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
// Input
StringBuilder buffer = new StringBuilder();
BufferedReader reader = req.getReader();
String line;
while ((line = reader.readLine()) != null) {
buffer.append(line);
}
String data = buffer.toString();
JSONParser inputParser = new JSONParser();
JSONObject input = null;
try
{
input = (JSONObject) inputParser.parse(data);
} catch (ParseException e) { e.printStackTrace(); }
String circuitId = (String) input.get("circuit");
System.out.println(circuitId);
DaoFactory daoFactory = DaoFactory.getInstance();
this.circuitDao = daoFactory.getCircuitDao();
// Variables - similaire au script de la classe Circuit.java
LinkedList<Variable> _variables = new LinkedList<Variable>();
JSONParser parser = new JSONParser();
try {
JSONArray JSONVariables = (JSONArray) parser.parse(this.circuitDao.get(Integer.parseInt(circuitId)).getVariablesAsString());
for (Object o : JSONVariables) {
JSONObject var = (JSONObject) o;
String value = (String) var.get("value");
// Eviter les divisions par zero :
if(value.equals("")) {
value = "1";
}
if(var.get("type").equals("form-dynamic")) {
_variables.add(new DynamicVariable(
(String) var.get("_name"),
(String) var.get("name"),
(String) var.get("expression"),
(Double) Double.valueOf(value),
(String) var.get("unit"),
(String) var.get("group")
));
}
if(var.get("type").equals("form-static")) {
_variables.add(new StaticVariable(
(String) var.get("_name"),
(String) var.get("name"),
(String) var.get("expression"),
(Double) Double.valueOf(value),
(String) var.get("unit"),
(String) var.get("group")
));
}
}
this.variables = _variables;
} catch (Exception e) {
e.printStackTrace();
}
/*
String circuitName = (String) input.get("circuit");
System.out.println(circuitName);
// Variables - similaire au script de la classe Circuit.java
LinkedList<Variable> _variables = new LinkedList<Variable>();
JSONParser parser = new JSONParser();
try {
JSONArray JSONVariables = (JSONArray) parser.parse(new FileReader(getServletContext().getRealPath("/") + "circuits/" + circuitName + ".json"));
for (Object o : JSONVariables) {
JSONObject var = (JSONObject) o;
String value = (String) var.get("value");
// Eviter les divisions par zero :
if(value.equals("")) {
value = "1";
}
if(var.get("type").equals("form-dynamic")) {
_variables.add(new DynamicVariable(
(String) var.get("_name"),
(String) var.get("name"),
(String) var.get("expression"),
(Double) Double.valueOf(value),
(String) var.get("unit"),
(String) var.get("group")
));
}
if(var.get("type").equals("form-static")) {
_variables.add(new StaticVariable(
(String) var.get("_name"),
(String) var.get("name"),
(String) var.get("expression"),
(Double) Double.valueOf(value),
(String) var.get("unit"),
(String) var.get("group")
));
}
}
this.variables = _variables;
} catch (Exception e) {
e.printStackTrace();
}
*/
// Output
resp.setContentType("application/json");
resp.setCharacterEncoding("utf-8");
Gson gson = new Gson();
Type listType = new TypeToken<LinkedList<Variable>>() {}.getType();
String json = gson.toJson(this.variables, listType);
PrintWriter out = resp.getWriter();
out.print(json);
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package berlin.iconn.rbm.views;
import berlin.iconn.rbm.main.AController;
import berlin.iconn.rbm.main.BenchmarkModel;
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.geometry.Rectangle2D;
import javafx.scene.Node;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.AnchorPane;
/**
* FXML Controller class
*
* @author christoph
*/
public class FaceRepairController extends AController {
/**
* Initializes the controller class.
*/
private BenchmarkModel benchmarkModel;
@FXML
private AnchorPane view;
@FXML
private Button btn_loadImage;
@FXML
private ImageView imgv_Image;
private FaceRepairModel model;
@FXML
private TextField txt_minEdgeSize;
@FXML
private CheckBox cbx_binarize;
@FXML
private Button btn_export;
@FXML
private Button btn_repair;
@FXML
private Label lbl_mousePos;
@Override
public void initialize(URL url, ResourceBundle rb) {
this.model = new FaceRepairModel(this);
this.imgv_Image.setPreserveRatio(true);
Rectangle2D viewPort = new Rectangle2D(0, 0, 400, 300);
this.imgv_Image.setViewport(viewPort);
this.update();
}
@Override
public Node getView() {
return this.view;
}
public ImageView getImageView(){
return this.imgv_Image;
}
public void setBenchmarkModel(BenchmarkModel model){
this.benchmarkModel = model;
}
public BenchmarkModel getBenchmarkModel(){
return this.benchmarkModel;
}
@FXML
private void btn_loadImageAction(ActionEvent event) {
this.model.loadImageFile();
}
@FXML
private void btn_repairAction(ActionEvent event) {
this.model.repairImage();
}
@FXML
private void txt_minEdgeSizeAction(ActionEvent event) {
this.model.setMinEdgeSize(new Integer(this.txt_minEdgeSize.getText()));
}
@FXML
private void cbx_binarizeAction(ActionEvent event) {
this.model.setBinarize(this.cbx_binarize.isSelected());
}
@Override
public void update(){
txt_minEdgeSize.setText(Integer.toString(this.model.getMinEdgeSize()));
cbx_binarize.setSelected(this.model.isBinarize());
}
@FXML
private void btn_exportAction(ActionEvent event) {
this.model.exportImage();
}
@FXML
private void imgv_ImageMouseClicked(MouseEvent event) {
lbl_mousePos.setText("x: " + event.getX() + ", y: " + event.getY());
}
}
|
package vanadis.extrt;
public class InheritedInject implements InjectHeritage {
private TestService service;
@Override
public void setTestService(TestService service) {
this.service = service;
}
public TestService getService() {
return service;
}
}
|
package com.example.leegyowon.myapplication;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.SeekBar;
import android.widget.TextView;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final TextView tv = (TextView)findViewById(R.id.textView1);
CustomSeekBar sb = (CustomSeekBar) findViewById(R.id.seekBar1);
sb.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
String time="";
public void onStopTrackingTouch(SeekBar seekBar) {
tv.setText(time);
}
public void onStartTrackingTouch(SeekBar seekBar) {
}
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
int stepSize=1;
progress=(progress/stepSize)*stepSize;
seekBar.setProgress(progress);
switch (progress){
case 0:
time="30분";
break;
case 1:
time="1시간";
break;
case 2:
time="2시간";
break;
case 3:
time="3시간";
break;
case 4:
time="4시간";
break;
default:
break;
}
}
});
}
}
|
package com.odm.managesystem.controller;
import com.alibaba.fastjson.JSONObject;
import com.odm.managesystem.service.InitPageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Hello {
@RequestMapping("/index")
public String hello(){
return "The ODM manage system project starts!";
}
}
|
package ADD;
import java.util.Objects;
import java.util.Arrays;
public class Node
{
protected static final int NUMBER_CHILDS = 2;
protected String name;
protected boolean primed;
protected Node[] childs;
protected Integer hashCode;
protected Integer hashCodeVar;
public Node()
{
childs = new Node[NUMBER_CHILDS];
primed = false;
}
public Node(String name)
{
this.name = name;
childs = new Node[NUMBER_CHILDS];
primed = false;
}
public Node(String name, boolean primed)
{
this.name = name;
this.primed = primed;
childs = new Node[NUMBER_CHILDS];
}
public Node(String name, boolean primed, int hashCodeVar)
{
this.name = name;
this.primed = primed;
childs = new Node[NUMBER_CHILDS];
this.hashCodeVar = hashCodeVar;
}
public void prime()
{
primed = true;
}
public void addChild(Node child, int side)
{
childs[side] = child;
}
public Node getChild(int i)
{
return childs[i];
}
public boolean isTerminal()
{
return false;
}
public boolean equals(Node aux)
{
if(aux.isTerminal()) return false;
if(hashCode() == aux.hashCode()) return true;
return false;
}
public String print()
{
return name + (primed ? "'" : "");
}
// Check on the dictionary
public Node times(Node n2)
{
return Dictionary.getItem(this, n2, Dictionary.TIMES);
}
// Check on the dictionary
public Node sum(Node n2)
{
return Dictionary.getItem(this, n2, Dictionary.SUM);
}
// Check on the dictionary
public Node max(Node n2)
{
return Dictionary.getItem(this, n2, Dictionary.MAX);
}
// Check on the dictionary
public Node minus(Node n2)
{
return Dictionary.getItem(this, n2, Dictionary.MINUS);
}
public Node setCost(Node n2)
{
return null;
}
// Check on the dictionary
public double absMinus(Node n2)
{
return 0;
}
public Node copy()
{
// Node copy = null;
// if(hashCodeVar != null) new Node(name, primed, hashCodeVar);
// else copy = new Node(name, primed);
Node copy = new Node(name, primed);
return copy;
}
public int hashCode()
{
if(hashCodeVar == null) hashCodeVar = print().hashCode();
// return print().hashCode();
return hashCodeVar;
}
// Reset the hashCode before change the ADD
public void resetCode()
{
hashCode = null;
}
String testeString = null;
public String getTesteString()
{
if(testeString == null) testeString = print() + childs[0].getTesteString() + childs[1].getTesteString();
return testeString;
}
// Combine the var code with the children code
public int treeHashCode()
{
if(this.hashCode != null) return this.hashCode;
// this.hashCode = Objects.hash(hashCode(), childs[0].treeHashCode(), childs[1].treeHashCode());
this.hashCode = hashCode()*173 + childs[0].treeHashCode()*1129^1 + childs[1].treeHashCode()*263;
// Integer[] keys = {hashCode(), childs[0].treeHashCode(), childs[1].treeHashCode()};
// hashCode = Arrays.hashCode(keys);
// this.hashCode = getTesteString().hashCode();
// this.hashCode = super.hashCode();
return hashCode;
}
}
|
package task114;
/**
* @author Igor
*/
public class Main114a {
public static void main(String[] args) {
int n = 7;
long dp[] = new long[n + 2];
dp[0] = 1;
for (int i = 0; i <= n; i++) {
dp[i + 1] += dp[i];
for (int j = i + 4; j <= n + 1; j++) {
dp[j] += dp[i];
}
}
System.out.println(dp[n + 1]);
}
}
|
package com.example.wuzp.xmlparsedemo.view.main;
import android.content.res.AssetManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.example.wuzp.xmlparsedemo.R;
import com.example.wuzp.xmlparsedemo.base.BindActivity;
import com.example.wuzp.xmlparsedemo.databinding.ActivityMainBinding;
import com.example.wuzp.xmlparsedemo.imp.XmlParseCallback;
import com.example.wuzp.xmlparsedemo.model.NodeBean;
import com.example.wuzp.xmlparsedemo.model.StudentBean;
import com.example.wuzp.xmlparsedemo.utils.SaxHandler;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
public class MainActivity extends BindActivity<ActivityMainBinding, MainPresenter> implements
MainContract.IView, View.OnClickListener {
private MainViewWrapper viewWrapper = new MainViewWrapper();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initView();
}
@Override
public MainPresenter createPresenter() {
return new MainPresenter(this);
}
@Override
public int createLayout() {
return R.layout.activity_main;
}
private void initView() {
viewWrapper.addBinding(binding);
binding.btnSax.setOnClickListener(this);
binding.btnPull.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_sax:
saxParseXml();
break;
case R.id.btn_pull:
List<StudentBean> date = pullParseXml();
if(date != null){
Log.e("wzp","pull size:" + date.size());
}else
Log.e("wzp","pull size: null");
break;
}
}
private void saxParseXml() {
try {
AssetManager assetManager = getResources().getAssets();
InputStream inputStream = assetManager.open("nodes.xml");
SAXParserFactory factory
= SAXParserFactory.newInstance();
SAXParser parse = factory.newSAXParser();
parse.parse(inputStream, new SaxHandler(callBack));
} catch (Exception e) {
}
}
private XmlParseCallback callBack = new XmlParseCallback() {
@Override
public void parseCallback(List<NodeBean> date) {
if(date != null){
Log.e("wzp","sax size:" + date.size());
}else
Log.e("wzp","sax size: null");
}
};
private List<StudentBean> pullParseXml() {
List<StudentBean> nodeBeanList = new ArrayList<>();//java7 中的泛型推断
StudentBean tempBean = null;
try {
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser pullParser = factory.newPullParser();
AssetManager assetManager = getAssets();
InputStream inputStream = assetManager.open("students.xml");
pullParser.setInput(inputStream, "UTF-8");
int eventType = pullParser.getEventType();
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_DOCUMENT:
break;
case XmlPullParser.START_TAG:
String tagName = pullParser.getName();
switch (tagName) {
case "student":
tempBean = new StudentBean();
tempBean.setId(pullParser.getAttributeValue(0));
tempBean.setGroup(pullParser.getAttributeName(1));
break;
case "name":
if (tempBean != null)
tempBean.setName(pullParser.getText());
break;
case "sex":
if (tempBean != null)
tempBean.setSex(pullParser.getText());
break;
case "age":
if (tempBean != null)
tempBean.setAge(pullParser.getText());
break;
case "email":
if (tempBean != null)
tempBean.setEmail(pullParser.getText());
break;
case "birthday":
if (tempBean != null)
tempBean.setBirthday(pullParser.getText());
break;
case "memo":
if (tempBean != null)
tempBean.setMemo(pullParser.getText());
break;
}
break;
case XmlPullParser.END_TAG:
String name = pullParser.getName();
switch (name) {
case "student":
if (tempBean != null)
nodeBeanList.add(tempBean);
break;
}
break;
}
eventType = eventType = pullParser.next();///调用的是next的方法 来获取当前的状态
}
} catch (Exception e) {
}
return nodeBeanList;
}
}
|
class Car extends Vehicle {
public Car() {
spotsNeeded = 1;
vehicleSize = VehicleSize.Compact;
}
public boolean canFitInSpot(ParkingSpot parkingSpot) {
return parkingSpot.getVehicleSize() == VehicleSize.Compact || parkingSpot.getVehicleSize() == VehicleSize.Large;
}
public void print() {
System.out.println("Car");
}
}
|
package useStandartExceptions;
public class UseStandartExceptions {
public static void main(String[] args) {
exceptionMethod(-5);
}
public static void exceptionMethod(int i){
if(i<0)throw new IllegalArgumentException("i < 0");
}
}
|
/* 1: */ package com.kaldin.common.db;
/* 2: */
/* 3: */ import java.sql.SQLException;
/* 4: */
/* 5: */ public class ExceptionFactory
/* 6: */ {
/* 7: */ public static DatabaseException getException(int databaseType, String msg, SQLException e)
/* 8: */ {
/* 9:27 */ switch (databaseType)
/* 10: */ {
/* 11: */ case 2:
/* 12:29 */ return new MySQLException(msg, e);
/* 13: */ }
/* 14:31 */ return null;
/* 15: */ }
/* 16: */
/* 17: */ public static DatabaseException getException(int databaseType, String msg)
/* 18: */ {
/* 19:43 */ switch (databaseType)
/* 20: */ {
/* 21: */ case 2:
/* 22:45 */ return new MySQLException(msg);
/* 23: */ }
/* 24:47 */ return null;
/* 25: */ }
/* 26: */ }
/* Location: C:\Java Work\Workspace\Kaldin\WebContent\WEB-INF\classes\com\kaldin\kaldin_java.zip
* Qualified Name: kaldin.common.db.ExceptionFactory
* JD-Core Version: 0.7.0.1
*/
|
package net.plazmix.core.api.common.orm;
public interface Column {
String getName();
Class<?> getType();
boolean isNullable();
boolean isUnique();
boolean isInsertable();
boolean isUpdatable();
boolean isPrimary();
default int length() {
return 255;
}
}
|
package com.pfchoice.springboot.service;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import com.pfchoice.springboot.model.MembershipHedisProblem;
public interface MembershipHedisProblemService {
MembershipHedisProblem findById(Integer id);
void saveMembershipHedisProblem(MembershipHedisProblem membershipClaim);
void updateMembershipHedisProblem(MembershipHedisProblem membershipClaim);
void deleteMembershipHedisProblemById(Integer id);
void deleteAllMembershipHedisProblems();
List<MembershipHedisProblem> findAllMembershipHedisProblems();
Page<MembershipHedisProblem> findAllMembershipHedisProblemsByPage(Specification<MembershipHedisProblem> spec, Pageable pageable);
boolean isMembershipHedisProblemExist(MembershipHedisProblem membership);
Integer loadData(Map<String, Object> parameters, String insuranceCode) throws IOException, InterruptedException;
}
|
package com.fab.devportal.service;
import java.util.List;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import com.fab.devportal.dao.SubApiTbl;
public interface SubApiService {
public List<SubApiTbl> findByParentApiName(String parentapiname);
public Iterable<SubApiTbl> findAll();
public Page<SubApiTbl> findAllPageable(Pageable pageable);
}
|
package net.optifine.entity.model;
import net.minecraft.client.Minecraft;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelPig;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.entity.RenderPig;
import net.minecraft.entity.passive.EntityPig;
public class ModelAdapterPig extends ModelAdapterQuadruped {
public ModelAdapterPig() {
super(EntityPig.class, "pig", 0.7F);
}
public ModelBase makeModel() {
return (ModelBase)new ModelPig();
}
public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize) {
RenderManager rendermanager = Minecraft.getMinecraft().getRenderManager();
RenderPig renderpig = new RenderPig(rendermanager);
renderpig.mainModel = modelBase;
renderpig.shadowSize = shadowSize;
return (IEntityRenderer)renderpig;
}
}
/* Location: C:\Users\BSV\AppData\Local\Temp\Rar$DRa6216.20396\Preview\Preview.jar!\net\optifine\entity\model\ModelAdapterPig.class
* Java compiler version: 8 (52.0)
* JD-Core Version: 1.1.3
*/
|
package com.lolRiver.river.persistence;
import com.lolRiver.river.models.State;
import com.lolRiver.river.models.Video;
import com.lolRiver.river.persistence.interfaces.VideoDao;
import com.lolRiver.river.util.DateUtil;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;
import javax.sql.DataSource;
import java.sql.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author mxia (mxia@lolRiver.com)
* 9/30/13
*/
@Repository
public class JdbcVideoDao implements VideoDao {
private static final Logger LOGGER = Logger.getLogger(JdbcVideoDao.class);
private static String GET_GIVEN_ID_SQL = "SELECT * FROM videos WHERE id = :id";
private static String GET_QUEUED_SQL = "SELECT * " +
"FROM videos " +
"WHERE state = 'QUEUED' " +
"ORDER BY queued_at ASC";
private static String INSERT_SQL = "INSERT INTO videos (streamer_name, url, views, start_time, end_time, length) VALUES (?,?,?,?,?,?)";
private static String UPDATE_NONQUEUED_STATE_SQL = "UPDATE videos " +
"SET state = ? " +
"WHERE id = ?";
private static String UPDATE_QUEUED_STATE_SQL = "UPDATE videos " +
"SET state = ?" +
", queued_at = ?" +
"WHERE id = ?";
private NamedParameterJdbcTemplate namedParamJdbcTemplate;
private JdbcTemplate jdbcTemplate;
private VideoRowMapper rowMapper = new VideoRowMapper();
@Autowired
public void init(final DataSource dataSource) {
namedParamJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplate = new JdbcTemplate(dataSource);
}
// helper method to handle results with num rows != 1
private Video queryForVideo(final String sql, final Video ap,
final RowMapper<Video> rowMapper) {
try {
return namedParamJdbcTemplate.queryForObject(sql, new BeanPropertySqlParameterSource(ap), rowMapper);
} catch (final EmptyResultDataAccessException e) {
// not an error when no rows were found
return null;
}
}
@Override
public Video getVideoFromId(int id) {
final Video queryObject = new Video();
queryObject.setId(id);
return queryForVideo(GET_GIVEN_ID_SQL, queryObject, rowMapper);
}
@Override
public List<Video> getUncovertedVideos() {
return jdbcTemplate.query(GET_QUEUED_SQL, rowMapper);
}
@Override
public Video insertVideo(final Video video) {
LOGGER.debug("Creating Video with values: " + video + " using query: " + INSERT_SQL);
if (video == null) {
return null;
}
final KeyHolder holder = new GeneratedKeyHolder();
try {
jdbcTemplate.update(new PreparedStatementCreator() {
@Override
public PreparedStatement createPreparedStatement(final Connection connection) throws SQLException {
final PreparedStatement ps = connection.prepareStatement(INSERT_SQL, Statement.RETURN_GENERATED_KEYS);
ps.setString(1, video.getStreamerName());
ps.setString(2, video.getUrl());
ps.setInt(3, video.getViews());
ps.setTimestamp(4, video.getStartTime());
ps.setTimestamp(5, video.getEndTime());
ps.setInt(6, video.getLength());
return ps;
}
}, holder);
} catch (DuplicateKeyException e) {
// ignore
return null;
}
return getVideoFromId(holder.getKey().intValue());
}
@Override
public boolean updateVideoState(final int id, final State state) {
Map<String, String> map = new HashMap<String, String>();
map.put("id", String.valueOf(id));
map.put("state", state.name());
final Object[] params;
String queryString;
if (state == State.QUEUED) {
params = new Object[]{state.name(), DateUtil.getCurrentTimestamp(), String.valueOf(id)};
queryString = UPDATE_QUEUED_STATE_SQL;
} else {
params = new Object[]{state.name(), String.valueOf(id)};
queryString = UPDATE_NONQUEUED_STATE_SQL;
}
try {
jdbcTemplate.update(queryString, params);
} catch (final DataAccessException e) {
LOGGER.error("couldn't update video: " + id + " to state: " + state, e);
return false;
}
return true;
}
// Extract Video results from a JDBC result set
public final class VideoRowMapper implements RowMapper<Video> {
@Override
public Video mapRow(final ResultSet resultSet, final int i) throws SQLException {
final int id = resultSet.getInt(Video.ID_STRING);
final String streamerName = resultSet.getString(Video.STREAMER_NAME_STRING);
final String url = resultSet.getString(Video.URL_STRING);
final Timestamp startTime = resultSet.getTimestamp(Video.START_TIME_STRING);
final Timestamp endTime = resultSet.getTimestamp(Video.END_TIME_STRING);
final int length = resultSet.getInt(Video.LENGTH_STRING);
final int views = resultSet.getInt(Video.VIEWS_STRING);
return new Video()
.setId(id)
.setStreamerName(streamerName)
.setUrl(url)
.setStartTime(startTime)
.setEndTime(endTime)
.setLength(length)
.setViews(views);
}
}
}
|
package interpreter.ast.nodes;
import interpreter.Visitor;
public interface Node
{
Object accept(Visitor v, Object o);
}
|
//package it.polimi.se2019;
//
//import it.polimi.se2019.controller.GameBoardController;
//import it.polimi.se2019.controller.PlayerController;
//import it.polimi.se2019.model.GameBoard;
//import it.polimi.se2019.model.map.UnknownMapTypeException;
//import it.polimi.se2019.model.player.Player;
//import it.polimi.se2019.view.player.PlayerViewOnServer;
//import org.junit.Test;
//import org.junit.runner.RunWith;
//import org.mockito.Mock;
//import org.mockito.runners.MockitoJUnitRunner;
//
//@RunWith(MockitoJUnitRunner.class)
//public class TestPowerUps {
// @Mock
// PlayerViewOnServer client;
//
// GameBoard gameBoard = new GameBoard(0);
// Player player = new Player("playerName", "playerCharacter", gameBoard);
// Player shooter = new Player("shooterName", "shooterCharacter", gameBoard);
// GameBoardController gameBoardController = new GameBoardController(gameBoard);
// PlayerController playerController = new PlayerController(gameBoardController, player, client);
//
// public TestPowerUps() throws UnknownMapTypeException {}
//
// @Test
// public void newtonTest(){
//
// }
//}
|
package model;
import java.sql.Timestamp;
import lombok.Getter;
import lombok.Setter;
public class UserModel extends Model {
private static final long serialVersionUID = 1L;
@Getter @Setter private int id;
@Getter @Setter private String username;
@Getter @Setter private String email;
@Getter @Setter private String encryptedPassword;
@Getter @Setter private Timestamp createdAt;
@Getter @Setter private Timestamp updatedAt;
}
|
package com.landg.myaccount.ui;
public class User {
private String PartyID;
public User() {
}
public User(String partyID) {
PartyID = partyID;
}
public void setPartyID(String partyID) {
PartyID = partyID;
}
public String getPartyID() {
return PartyID;
}
}
|
package com.ali.rent.service;
import com.ali.rent.pojo.Room;
import java.util.List;
public interface RoomService {
List<Room> selectAll();
Integer updateById(Integer id);
Room getRoomById(Integer id);
Integer insertRooom(Room room);
List<Room> selectSortordAll(String site,String pattern,String layout,String pricemin,String pricemax,String sortord);
}
|
package prefeitura.siab.apresentacao;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import prefeitura.siab.controller.AcsController;
import prefeitura.siab.controller.BusinessException;
import prefeitura.siab.tabela.Acs;
@Component
@Scope(WebApplicationContext.SCOPE_REQUEST)
public class NewAcs {
//ATRIBUTOS
private @Autowired AcsController controller;
private Acs agente;
//PROPRIEDADES
public AcsController getController() {
return controller;
}
public void setController(AcsController controller) {
this.controller = controller;
}
public Acs getAgente() {
return agente;
}
public void setAgente(Acs agente) {
this.agente = agente;
}
//CONSTRUTOR
public NewAcs() {
agente = new Acs();
}
//MÉTODOS
public String saveAcs(){
FacesMessage message = new FacesMessage();
try{
controller.salvarAcs(agente);
message.setSummary("ACS Cadastrado com Sucesso!");
message.setSeverity(FacesMessage.SEVERITY_INFO);
}catch(BusinessException e){
message.setSummary(e.getMessage());
message.setSeverity(FacesMessage.SEVERITY_ERROR);
}
FacesContext context = FacesContext.getCurrentInstance();
context.addMessage(null, message);
return null;
}
}
|
package com.zen.model.manage.service;
import com.alibaba.fastjson.JSONObject;
import com.zen.model.manage.dto.ModelInfoDto;
import org.springframework.web.multipart.MultipartFile;
import javax.xml.bind.ValidationException;
import java.util.List;
/**
* @Author: morris
* @Date: 2020/6/11 15:43
* @description
* @reviewer
*/
public interface ManageService {
String createModel(ModelInfoDto modelInfoDto);
/**
* 更新模型
* @param modelInfoDto 模型信息
* @return
* @throws ValidationException
*/
String updateModel(ModelInfoDto modelInfoDto) throws ValidationException;
String offlineModel(String token);
JSONObject rollbackModel(String token);
String deleteModel(String token, Integer version);
/**
* 上传实体模型，并在 DB 添加模型记录，默认关闭模型
* @param path
* @param file
* @param token
* @return
* @Exception
*/
String uploadModelFile(String path, MultipartFile file, String token) throws Exception;
/**
* 获取状态下所有模型信息
* @param status
* @return
*/
List<ModelInfoDto> getModelList(Boolean status);
String uploadModelFile(String path, MultipartFile file) throws Exception;
}
|
package com.jinshu.xuzhi.feeling;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.drawable.BitmapDrawable;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.util.Log;
import android.widget.ImageView;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* Created by xuzhi on 2017/3/23.
*/
public class Util {
private final String LOG_TAG = this.getClass().getSimpleName();
static final String CONSTANTS_RES_PREFIX = "android.resource://com.jinshu.xuzhi.feeling/";
static final String IMAGE_FILE_NAME = "1111.jpg";
static int i = 0;
static Boolean fishingTag = false;
static Uri getTempUri() {
return Uri.fromFile(getTempFile());
}
/**
* 临时图片保存路径
* @return
*/
static File getTempFile() {
File file = new File(Environment.getExternalStorageDirectory(), IMAGE_FILE_NAME);
//Log.v("getTempFile","getTempFile" + i++);
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
return file;
}
static Bitmap decodeUriAsBitmap(Context context,Uri uri) {
Bitmap bitmap = null;
try {
// 先通过getContentResolver方法获得一个ContentResolver实例，
// 调用openInputStream(Uri)方法获得uri关联的数据流stream
// 把上一步获得的数据流解析成为bitmap
bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(uri));
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
}
return bitmap;
}
// 缩放图片
static Bitmap zoomImg(Bitmap bm, int newWidth ,int newHeight){
// 获得图片的宽高
int width = bm.getWidth();
int height = bm.getHeight();
// 计算缩放比例
float scaleWidth = ((float) newWidth) / width;
float scaleHeight = ((float) newHeight) / height;
// 取得想要缩放的matrix参数
Matrix matrix = new Matrix();
matrix.postScale(scaleWidth, scaleHeight);
// 得到新的图片
Bitmap newbm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
return newbm;
}
//显示自定义图片
static void ShowCustomPicture(Context context,ImageView target, int scale)
{
File file = new File(Environment.getExternalStorageDirectory(), IMAGE_FILE_NAME);
if (file.exists())
{
Bitmap bitmap = null;
try {
// 先通过getContentResolver方法获得一个ContentResolver实例，
// 调用openInputStream(Uri)方法获得uri关联的数据流stream
// 把上一步获得的数据流解析成为bitmap
bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(Uri.fromFile(file)));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// 把解析到的位图显示出来
if (scale != 0)
{
bitmap = zoomImg(bitmap,scale,scale);
}
target.setImageBitmap(bitmap);
}
}
/*play audio*/
static void PlayAudio(Context context, MediaPlayer player, String voice)
{
try {
player.reset();
int id = context.getResources().getIdentifier(voice, "raw", "com.jinshu.xuzhi.feeling");
String uriString = Util.CONSTANTS_RES_PREFIX + Integer.toString(id);
//Log.v(LOG_TAG,uriString);
player.setDataSource(context, Uri.parse(uriString));
player.prepareAsync();
} catch (IOException e) {
e.printStackTrace();
}
}
static int mScreenWidth,mScreenHeight;
static void getScreenSize(Activity activity){
DisplayMetrics outMetrics = new DisplayMetrics();
activity.getWindowManager().getDefaultDisplay().getMetrics(outMetrics);
mScreenWidth = outMetrics.widthPixels;
mScreenHeight = outMetrics.heightPixels;
Log.v("Util","mScreenWidth = " + mScreenWidth + ",mScreenHeight = " + mScreenHeight);
}
public static Bitmap combineImages(Context context,int backgroundId,int foregroundId,int scale)
{
Bitmap mergeImage = null,imageBackground = null,imageForeground = null;
try {
BitmapDrawable drawableBackground = (BitmapDrawable)context.getResources().getDrawable(backgroundId);
BitmapDrawable drawableForeground = (BitmapDrawable)context.getResources().getDrawable(foregroundId);
imageBackground = drawableBackground.getBitmap();
imageForeground = drawableForeground.getBitmap();
} catch (Exception e) {
e.printStackTrace();
}
if (customFileExist())
{
Bitmap bitmap = null;
try {
// 先通过getContentResolver方法获得一个ContentResolver实例，
// 调用openInputStream(Uri)方法获得uri关联的数据流stream
// 把上一步获得的数据流解析成为bitmap
File file = new File(Environment.getExternalStorageDirectory(), IMAGE_FILE_NAME);
bitmap = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(Uri.fromFile(file)));
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
}
// 设置缩放过的图片为forground图片
imageForeground = zoomImg(bitmap,scale,scale);
}
mergeImage = Bitmap.createBitmap(imageBackground.getWidth(), imageBackground.getHeight(), Bitmap.Config.ARGB_8888);
Canvas comboImage = new Canvas(mergeImage);
comboImage.drawBitmap(imageBackground, 0f, 0f, null);
comboImage.drawBitmap(imageForeground, (imageBackground.getWidth()/2 - imageForeground.getWidth()/2), (imageBackground.getHeight() - imageForeground.getHeight() - 60), null);
return mergeImage;
}
static boolean customFileExist()
{
File file = new File(Environment.getExternalStorageDirectory(), IMAGE_FILE_NAME);
if (file.exists() && (file.length() > 0))
{
return true;
}
else{
return false;
}
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package Aula5.Exercicio2;
import java.util.Date;
/**
*
* @author mauricio.moreira
*/
public class Venda {
private int codigo;
public Date data;
public Cliente cliente;
public Funcionario funcionario;
public Venda(int codigo, Cliente cliente, Funcionario funcionario) {
this.codigo = codigo;
this.cliente = cliente;
this.funcionario = funcionario;
}
public int getCodigo(){
return codigo;
}
// public void setCliente(Cliente cliente) {
// this.cliente = cliente;
// }
}
|
package com.example.tiamo.gym;
import android.content.Context;
import android.content.Intent;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import java.util.Random;
import java.util.Date;
public class RecyclerViewAdapter extends RecyclerView.Adapter<RecyclerViewAdapter.ViewHolder>{
//数据
private String[] mDataset;
private Context context;
private String selectname;
public RecyclerViewAdapter(String[] mDataset, Context context){
super();
this.mDataset = mDataset;
this.context= context;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i){
final View view = View.inflate(viewGroup.getContext(), R.layout.fragment_page3, null);
final ViewHolder holder = new ViewHolder(view) ;
holder.coachItem_TextView = (TextView) view.findViewById(R.id.coach_item);
holder.coach_item_provider_TextView = (TextView) view.findViewById(R.id.coach_item_provider);
holder.coach_item_provider_TextView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
selectname= holder.coach_item_provider_TextView.getText().toString();
Log.d("RecyclerViewAdapter", "ssssssssssssssssssssssssssssssssssss");
Log.d("RecyclerViewAdapter", selectname);
Intent intent = new Intent(context, trainerinfo.class);
intent.putExtra("namemsg",selectname);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
context.startActivity(intent);
}
});
holder.coach_item_time_TextView = (TextView) view.findViewById(R.id.coach_item_time);
holder.coach_item_cost_TextView = (TextView) view.findViewById(R.id.coach_item_cost);
holder.again_button = (Button) view.findViewById(R.id.again_button);
holder.again_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
holder.again_button.setText("记得参加");
}
});
//holder.evaluate_button = (Button) view.findViewById(R.id.evaluate_button);
holder.route_plan = (ImageView) view.findViewById(R.id.route);
holder.route_plan.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(context, WalkRouteActivity.class);
context.startActivity(intent);
}
});
return holder;
}
@Override
public void onBindViewHolder(ViewHolder viewHolder, int i){
//绑定数据到Holder上
int name = (int) (Math.random() * 3);
switch (name){
case 0:
viewHolder.coachItem_TextView.setText(" 腹肌撕裂计划");
break;
case 1:
viewHolder.coachItem_TextView.setText(" 燃爆脂肪计划");
break;
case 2:
viewHolder.coachItem_TextView.setText(" 练死我的腿计划");
break;
}
int provider = (int) (Math.random() * 3);
switch (provider){
case 1:
viewHolder.coach_item_provider_TextView.setText("冉旭松");
viewHolder.coach_item_time_TextView.setText("874030912@qq.com");
break;
case 2:
viewHolder.coach_item_provider_TextView.setText("薛飞跃");
viewHolder.coach_item_time_TextView.setText("731372395@qq.com");
break;
case 0:
viewHolder.coach_item_provider_TextView.setText("彭浩伟");
viewHolder.coach_item_time_TextView.setText("7472232323@qq.com");
break;
}
int cost = (int) (Math.random() * 600) + 200;
viewHolder.coach_item_cost_TextView.setText("总价：¥ " + cost);
}
@Override
public int getItemCount() {
return mDataset.length;
}
public static class ViewHolder extends RecyclerView.ViewHolder{
public TextView coachItem_TextView;
public TextView coach_item_provider_TextView;
public TextView coach_item_time_TextView;
public TextView coach_item_cost_TextView;
public Button again_button;
// public Button evaluate_button;
public ImageView route_plan;
public ViewHolder(View itemView) {
super(itemView);
}
}
}
|
package com.spr.service;
import com.spr.beans.Message;
import com.spr.beans.ProfileUser;
import com.spr.rest.InsertEdgeDTO;
import java.util.List;
/**
* Created by saurav on 27/03/17.
*/
public interface GraphJetService {
String insertEdge(InsertEdgeDTO insertEdgeDTO);
String createGraph();
List<ProfileUser> topUsers(int count);
List<Message> topMessages(int count);
List<String> topHashTags(int count);
List<Message> topMessages(Long userId, int count);
List<ProfileUser> topUsers(Long msgId, int count);
}
|
package com.cybertek.utilities;
public class Assert {
public static void fail(String s) {
}
public static void assertTrue(boolean equals) {
}
}
|
package com.nxtlife.mgs.service;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.web.multipart.MultipartFile;
import com.nxtlife.mgs.view.GradeRequest;
import com.nxtlife.mgs.view.GradeResponse;
public interface GradeService {
ResponseEntity<?> uploadGradesFromExcel(MultipartFile file, String schoolCid);
GradeResponse save(GradeRequest request);
GradeResponse findByCid(String cId);
List<GradeResponse> getAllGradesOfSchool(String schoolCid);
}
|
package com.tencent.mm.ab;
import android.os.Looper;
import com.tencent.mm.ab.a.a;
import com.tencent.mm.protocal.c.bhp;
import com.tencent.mm.sdk.platformtools.ah;
import com.tencent.mm.sdk.platformtools.al;
import com.tencent.mm.sdk.platformtools.x;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;
public final class w {
public static <T extends bhp> a<T> b(b bVar) {
if (bVar == null) {
throw new IllegalArgumentException("Cant use NULL rr");
}
o DG = v.dKi == null ? null : v.dKi.DG();
if (DG == null) {
x.e("MicroMsg.SynchronousCgiCall", "NetSceneQueue not ready, just return NULL");
return null;
} else if (ah.isMainThread()) {
throw new IllegalAccessError("Cant call this function in main thread");
} else if (DG.dJt.lnJ.getLooper().getThread().getId() == Thread.currentThread().getId()) {
throw new IllegalAccessError("Cant call this function in NetSceneQueue's worker thread!!!");
} else {
final AtomicReference atomicReference = new AtomicReference();
final CountDownLatch countDownLatch = new CountDownLatch(1);
v.a(bVar, new v.a() {
public final int a(int i, int i2, String str, b bVar, l lVar) {
atomicReference.set(a.a(i, i2, str, (bhp) bVar.dIE.dIL, lVar, null));
countDownLatch.countDown();
return 0;
}
});
new al(Looper.getMainLooper(), new al.a() {
public final boolean vD() {
atomicReference.set(new a());
countDownLatch.countDown();
return false;
}
}, false).J(20000, 20000);
try {
countDownLatch.await();
return (a) atomicReference.get();
} catch (Throwable e) {
x.printErrStackTrace("MicroMsg.SynchronousCgiCall", e, "latch await exp ", new Object[0]);
return null;
}
}
}
public static <T extends bhp> a<T> a(a<T> aVar) {
o DG = v.dKi == null ? null : v.dKi.DG();
if (DG == null) {
x.e("MicroMsg.SynchronousCgiCall", "NetSceneQueue not ready, just return NULL");
return null;
} else if (ah.isMainThread()) {
throw new IllegalAccessError("Cant call this function in main thread");
} else if (DG.dJt.lnJ.getLooper().getThread().getId() == Thread.currentThread().getId()) {
throw new IllegalAccessError("Cant call this function in NetSceneQueue's worker thread!!!");
} else {
AtomicReference atomicReference = new AtomicReference();
CountDownLatch countDownLatch = new CountDownLatch(1);
aVar.KM().f(new 3(atomicReference, countDownLatch));
try {
countDownLatch.await();
return (a) atomicReference.get();
} catch (Throwable e) {
x.printErrStackTrace("MicroMsg.SynchronousCgiCall", e, "semaphore await exp ", new Object[0]);
return null;
}
}
}
}
|
package fr.demos.Data;
import java.util.List;
import fr.demos.formation.today.Climatisation;
//DAO: Data Access Object : objet qui sert a l'acces aux données
public interface ClimatisationDAO {
void sauve(Climatisation cl) throws Exception;
List <Climatisation> recherchetout() throws Exception; // on veut etre plus general que la array list
List <Climatisation> recherche (String critere) throws Exception;
int nombre(String Critere);
}
|
package com.wllfengshu.mysql.storage.impl;
import com.wllfengshu.mysql.common.Constant;
import com.wllfengshu.mysql.exception.CustomException;
import com.wllfengshu.mysql.model.dto.ExecutePlanDTO;
import com.wllfengshu.mysql.model.entity.ResultSet;
import com.wllfengshu.mysql.storage.StorageEngine;
import com.wllfengshu.mysql.utils.FileUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import java.io.File;
import java.io.RandomAccessFile;
import java.util.Arrays;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
* innodb引擎
*
* TODO 注意：暂时不考虑锁
*/
@Slf4j
@Configuration
@RequiredArgsConstructor
public class Innodb implements StorageEngine {
@Override
public ResultSet insert(ExecutePlanDTO executePlanDTO) throws CustomException {
//1 找到对应的文件
File tableFile = FileUtils.giveTableFile(executePlanDTO.getDbName(), executePlanDTO.getTableNames().get(0));
//2 从insert语句中解析出数据
String pending = FileUtils.giveContentByInsertSql(executePlanDTO.getSql());
//3 把数据插入对应的db、对应的ibd文件中
try (RandomAccessFile file = new RandomAccessFile(tableFile, "rw")) {
file.seek(file.length());
file.write(pending.getBytes(UTF_8));
}catch (Exception e){
throw new CustomException("写数据库失败", CustomException.ExceptionName.FAIL_INSERT);
}
return new ResultSet(true);
}
@Override
public ResultSet delete(ExecutePlanDTO executePlanDTO) throws CustomException {
//1 找到对应的文件
File tableFile = FileUtils.giveTableFile(executePlanDTO.getDbName(), executePlanDTO.getTableNames().get(0));
//2 找到对应的行
//3 删除对应的行
return null;
}
@Override
public ResultSet update(ExecutePlanDTO executePlanDTO) throws CustomException {
//1 找到对应的文件
File tableFile = FileUtils.giveTableFile(executePlanDTO.getDbName(), executePlanDTO.getTableNames().get(0));
//2 找到对应的行
//3 更新数据
//4 重新写入
return null;
}
@Override
public ResultSet select(ExecutePlanDTO executePlanDTO) throws CustomException {
//1 找到对应的文件
String content = FileUtils.readFile(Constant.DATA_PATH + "/" + executePlanDTO.getDbName() + "/" + executePlanDTO.getTableNames().get(0) + Constant.DATA_FILE_IBD);
//2 找到对应的行 TODO 暂时直接读取全部的
ResultSet resultSet = new ResultSet(true);
String[] split = content.split("\n");
resultSet.setContent(Arrays.asList(split));
return resultSet;
}
}
|
package com.gyk.s2h.varmisin;
/**
* Created by HULYA on 27.08.2017.
*/
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
import com.squareup.picasso.Picasso;
import com.squareup.picasso.Transformation;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.net.Uri;
import android.support.design.widget.FloatingActionButton;
import android.support.v4.app.FragmentActivity;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
//Iddialarım listemizi doldurmamızı sağlayan class
public class IddialarimAdapter extends BaseAdapter {
LayoutInflater layoutInflater;
ArrayList<YuruyusModel> iddiaList;
TextView adSoyad, Iddia;
ImageView resim;
FirebaseDatabase database;
private String userID, istekC;
private DatabaseReference mDatabase;
FloatingActionButton bekleme;
String istek;
List<String> arrList = new ArrayList<String>();
public IddialarimAdapter(FragmentActivity activity, ArrayList<YuruyusModel> iddiaList) {
layoutInflater = (LayoutInflater) activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
this.iddiaList = iddiaList;
}
@Override
public int getCount() {
return iddiaList.size();
}
@Override
public Object getItem(int i) {
return iddiaList.get(i);
}
@Override
public long getItemId(int i) {
return i;
}
@Override
public View getView(final int i, View view, ViewGroup viewGroup) {
YuruyusModel kisiModel = iddiaList.get(i);
final View satir = layoutInflater.inflate(R.layout.benim_yolladiklarim_list_item, null);
adSoyad = (TextView) satir.findViewById(R.id.adSoyad);
Iddia = (TextView) satir.findViewById(R.id.iddia);
bekleme = (FloatingActionButton) satir.findViewById(R.id.bekleme);
database = FirebaseDatabase.getInstance();
FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
userID = user.getUid();
Log.d("userID:", userID);
mDatabase = FirebaseDatabase.getInstance().getReference();
if(kisiModel.getIstek().equals("kabul")){
bekleme.setImageResource(R.drawable.check);
bekleme.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(satir.getContext(), "İstek kabul edildi.", Toast.LENGTH_SHORT).show();
}
});
}
else {
bekleme.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(satir.getContext(), "Onay bekleniyor...", Toast.LENGTH_SHORT).show();
}
});
}
adSoyad.setText(kisiModel.getIsim());
Iddia.setText(kisiModel.getSure() + " saat sürede " + kisiModel.getAdimS() + " adım");
return satir;
}
}
|
package com.example.aswantourguide;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import java.util.ArrayList;
/**
* A simple {@link Fragment} subclass.
*/
public class attractionsFragment extends Fragment {
public attractionsFragment() {
// Required empty public constructor
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view= inflater.inflate(R.layout.fragment_attractions,container,false);
ArrayList<locationAndDetails> details=new ArrayList<locationAndDetails>();
details.add(new locationAndDetails(getString(R.string.abu_simbel),getString(R.string.abu_simbel_details),R.drawable.abu_simbel));
details.add(new locationAndDetails(getString(R.string.nubia_museum),getString(R.string.nubia_museum_details),R.drawable.nubia_museum));
details.add(new locationAndDetails(getString(R.string.ruins_of_abu),getString(R.string.ruins_of_abu_details),R.drawable.ruins_of_abu));
details.add(new locationAndDetails(getString(R.string.botanical_gardens),getString(R.string.botanical_gardens_details),R.drawable.botanical_gardens));
ListView listView =view.findViewById(R.id.list);
tourGuideAdapter adapter =new tourGuideAdapter(getActivity(),details);
listView.setAdapter(adapter);
return view;
}
}
|
package cn.e3mall.service;
import java.util.List;
import cn.e3mall.common.pojo.EasyUIDataGridResult;
import cn.e3mall.common.util.E3Result;
import cn.e3mall.pojo.TbItem;
/**
* 商品service
* @author Dragon
*
*/
public interface ItemService {
/**
* 根据商品Id获取商品
* @param itemId
* @return
*/
TbItem getItemById(long itemId);
/**
* 分页获取商品信息
* @param page 当前页码
* @param rows 每页需要的记录数
* @return
*/
EasyUIDataGridResult getItemList(int page, int rows);
/**
* 添加商品
* @param item
* @param itemDesc
* @return
*/
E3Result addItem(TbItem item, String itemDesc);
/**
* 修改商品
* @param item
* @param itemDesc
* @return
*/
E3Result editItem(TbItem item, String itemDesc);
/**
* 根据商品ID删除商品
* @param itemIds
* @return
*/
E3Result deleteItemByIds(List<Long> itemIds);
/**
* 下架商品，根据商品ID
* @param itemIds
* @return
*/
E3Result instockItem(List<Long> itemIds);
/**
* 上架商品，根据商品ID
* @param itemIds
* @return
*/
E3Result reshelfItem(List<Long> itemIds);
}
|
package com.test.mjp.repository.service.serviceimplementation;
import com.test.mjp.entity.aimal.AnimalDetail;
import com.test.mjp.repository.service.serviceinterface.AnimalDetailsCacheService;
public class AnimalDetailsCacheServiceImpl implements AnimalDetailsCacheService {
private AnimalDetail animalDetailCache;
@Override
public AnimalDetail fetchAnimalDetails() {
return animalDetailCache;
}
@Override
public void putAnimalDetails(AnimalDetail animalDetail) {
animalDetailCache = animalDetail;
}
}
|
package calculation.calculations;
public class _Calculation_DivisionTest {
}
|
package ua.babiy.online_store.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import ua.babiy.online_store.entity.Cart;
import ua.babiy.online_store.entity.InCartProduct;
import java.util.Optional;
import java.util.Set;
public interface InCartProductRepository extends JpaRepository<InCartProduct, Long> {
Set<InCartProduct> findAllByCart(Cart cart);
void deleteAllByCart(Cart cart);
void deleteByCartAndProductId(Cart cart, Long productId);
Optional<InCartProduct> findByCartAndProductId(Cart cart, Long productId);
}
|
package dp;
import java.util.Arrays;
// !!!!!!!!!!!!!!!!!未完成！！！！！！！！！！！！！！！
public class GetMaxCoins {
// 一个N*M的矩阵上每个点都有一定数量的糖果。给你一个起点坐标X1、Y1和终点坐标X2、Y2，从起点到终点最多走K步，
// 每一步可以上下左右移动，但不能沿着对角线移动，每到达矩阵的一点可以拿走该点的糖果。请输出可以拿到的糖果的最大值。
//方法1：动态规划
public static int getMaxCoins(int[][] graph, int x1, int y1, int x2, int y2, int k) {
if(graph.length == 0)
return 0;
int m = graph.length;
int n = graph[0].length;
//dp[k][i][j]表示的是在第k次迭代的时候，（i，j）点所能收集到的最大糖果数目
int[][][] dp = new int[k+1][m][n];
for(int[][] A:dp) {
for(int[] B:A) {
Arrays.fill(B, 0);
}
}
//无论哪一轮迭代，起始点位置所能收集到的最多糖果数目就等于该处的糖果值
for (int i = 0; i < dp.length; i++) {
dp[i][x1][y1] = graph[x1][y1];
}
for(int i=1;i<=k;i++) {
//开始k轮迭代，每一轮表示扩充一步
for(int j=0;j<m;j++) {
for(int r=0;r<n;r++) {
if(dp[i-1][j][r] != 0) {
if(j-1>=0 && dp[i-1][j][r] + graph[j-1][r] > dp[i-1][j-1][r]) {
dp[i][j-1][r] = dp[i-1][j][r] + graph[j-1][r];
graph[j-1][r] = 0;
}
if(j+1<m && dp[i-1][j][r] + graph[j+1][r] > dp[i-1][j+1][r]) {
dp[i][j+1][r] = dp[i-1][j][r] + graph[j+1][r];
graph[j+1][r] = 0;
}
if(r-1>=0 && dp[i-1][j][r] + graph[j][r-1] > dp[i-1][j][r-1]) {
dp[i][j][r-1] = dp[i-1][j][r] + graph[j][r-1];
graph[j][r-1] = 0;
}
if(r+1<n && dp[i-1][j][r] + graph[j][r+1] > dp[i-1][j][r+1]) {
dp[i][j][r+1] = dp[i-1][j][r] + graph[j][r+1];
graph[j][r+1] = 0;
}
dp[i][j][r] = 0;
}
}
}
}
for(int[][] A:dp) {
for(int[] B:A) {
for(int r:B) {
System.out.print(r + " ");
}
System.out.println();
}
System.out.println();
}
return dp[k][x2][y2]==Integer.MIN_VALUE?-1:dp[k][x2][y2];
}
public static void main(String[] args) {
int[][] graph = {{1, 0, 2}, {0,1,3}, {9,2,0}, {0,0,1}};
int res = getMaxCoins(graph, 0, 0, 3, 2, 5);
System.out.println(res);
}
}
|
//package za.ac.cput.Repository;
//
//import za.ac.cput.Entity.ConsultationRecord;
//
//import java.util.HashSet;
//import java.util.Set;
//
//public class ConsultationRecordRepository implements IConsultationRecordRepository {
//
// //static helps with singleton
// private static ConsultationRecordRepository repository = null;
//
// private Set<ConsultationRecord> consultationRecordDB = null;
//
// public ConsultationRecordRepository(){
// this.consultationRecordDB = new HashSet<>();
// }
//
// public static ConsultationRecordRepository getRepository(){
// if(repository == null){
// repository = new ConsultationRecordRepository();
// }
// return repository;
// }
//
// @Override
// public Set<ConsultationRecord> getAll() {
// return consultationRecordDB;
// }
//
// @Override
// public ConsultationRecord create(ConsultationRecord consultationRecord) {
// this.consultationRecordDB.add(consultationRecord);
// return consultationRecord;
// }
//
// @Override
// public ConsultationRecord read(String s) {
// for(ConsultationRecord consultationRecord : this.consultationRecordDB){
//
// if(consultationRecord.getConsultationId().equalsIgnoreCase(s)){
// return consultationRecord;
// }
//
// }
// return null;
// }
//
// @Override
// public ConsultationRecord update(ConsultationRecord consultationRecord) {
// delete(consultationRecord.getConsultationId());
//
// this.consultationRecordDB.add(consultationRecord);
// return consultationRecord;
// }
//
// @Override
// public boolean delete(String s) {
// ConsultationRecord deleteConsultationRecord = read(s);
// this.consultationRecordDB.remove(deleteConsultationRecord);
// return true;
// }
//}
//
|
package assignment;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* An {@link Option} container that produces a default value through a {@link Producer}.
* @author I.A
*/
public final class None<T> implements Option<T> {
@Override
public <U> U visit(Supplier<U> onNone, Function<T, U> onSome) {
return onNone.get();
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package controller.admin;
import entity.OrderStatus;
import java.sql.SQLException;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import model.admin.AdminOrderStatusModel;
import model.admin.AdminUtil;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
*
* @author NamPA
*/
@Controller
@RequestMapping(value = "/adminOrderStatusController")
public class AdminOrderStatusController {
@RequestMapping(value = "/getAll")
public ModelAndView getAllOrderStatus() {
ModelAndView mav = new ModelAndView("admin/orderStatus/orderStatus");
List<OrderStatus> listOrderStatus = AdminOrderStatusModel.getAllOrderStatus();
mav.addObject("listOrderStatus", listOrderStatus);
return mav;
}
@RequestMapping(value = "/initInsert")
public ModelAndView initInsert() {
ModelAndView mav = new ModelAndView("admin/orderStatus/newOrderStatus");
OrderStatus orderStatusInsert = new OrderStatus();
mav.addObject("orderStatusInsert", orderStatusInsert);
return mav;
}
@RequestMapping(value = "/insert")
public String insert(OrderStatus orderStatusInsert) {
orderStatusInsert.setCreated(AdminUtil.getCurrentDate());
return AdminOrderStatusModel.addOrderStatus(orderStatusInsert) ? "redirect:getAll.htm" : "admin/error";
}
@RequestMapping(value = "/initUpdate")
public ModelAndView initUpdate(String orderStatusId) {
ModelAndView mav = new ModelAndView("admin/orderStatus/updateOrderStatus");
OrderStatus orderStatusUpdate = AdminOrderStatusModel.getOrderStatusById(orderStatusId);
mav.addObject("orderStatusUpdate", orderStatusUpdate);
return mav;
}
@RequestMapping(value = "/update")
public String updateOrderStatus(OrderStatus orderStatusUpdate) {
OrderStatus orderStatus = AdminOrderStatusModel.getOrderStatusById(String.valueOf(orderStatusUpdate.getOrderStatusId()));
orderStatusUpdate.setCreated(orderStatus.getCreated());
return AdminOrderStatusModel.updateOrderStatus(orderStatusUpdate) ? "redirect:getAll.htm" : "admin/error";
}
@RequestMapping(value = "/delete")
public String deleteOrderStatus(String orderStatusId, HttpServletRequest request) throws SQLException {
if (request.getSession().getAttribute("adminName") == null) {
return "redirect:/adminIndexController/login.htm";
}
return AdminOrderStatusModel.deleteOrderStatus(orderStatusId) ? "redirect:getAll.htm" : "admin/error";
}
}
|
package geometries;
import java.util.LinkedList;
import java.util.List;
import static primitives.Util.alignZero;
import primitives.*;
import static primitives.Util.isZero;
/**
* Sphere class represents sphere in 3D Cartesian coordinate
* system
* @author Tamar and Rina
*
*/
public class Sphere extends RadialGeometry
{
/**
* The center point of the sphere
*/
Point3D _center;
/**
* Sphere constructor based on radius and point
*
* @param c point
* @param r radius
*/
public Sphere(Point3D c, double r)
{
super(r);
_center = c;
}
/**
* Sphere constructor based on point, radius and color
*
* @param c
* @param r
* @param color
*/
public Sphere(Point3D c, double r, Color color)
{
this(c, r);
super._emission = color;
}
/**
* Sphere constructor based on point, radius, color and material
*
* @param c
* @param r
* @param color
* @param material
*/
public Sphere(Point3D c, double r, Color color, Material material)
{
this(c,r, color);
super._material = material;
}
/**
* get sphere normal
* @param p point on the sphere
* @return normal
*/
@Override
public Vector getNormal(Point3D p) {
Vector v1 = new Vector(p.subtract(_center));
return v1.normalized();
}
@Override
public List<GeoPoint> findIntersections(Ray ray) {
Vector L;
try
{
L = _center.subtract(ray._POO);
}
catch(IllegalArgumentException e)
{
return List.of(new GeoPoint(this, new Point3D(_center.add(ray._direction.scale(_radius)))));
}
double tm = alignZero(ray._direction.dotProduct(L));
//double d = L.length() - tm*tm;
double d = L.lengthSquared() - tm*tm;
//double th = alignZero(_radius*_radius - d*d);
double th = alignZero(_radius*_radius - d);
if(th<=0)
return null;
double th2 = alignZero(Math.sqrt(th));
if(th2 == 0)
return null;
double t1 = alignZero(tm - th2);
double t2 = alignZero(tm + th2);
if(t1<= 0 && t2<= 0)
return null;
LinkedList<GeoPoint> ans = new LinkedList<GeoPoint>();
if(t1 > 0)
{
//Point3D p1 = ray.getPoint(t1);
GeoPoint gp1 = new GeoPoint(this, ray.getPoint(t1));
ans.add(gp1);
}
if(t2 > 0)
{
//Point3D p2 = ray.getPoint(t2);
GeoPoint gp2 = new GeoPoint(this, ray.getPoint(t2));
ans.add(gp2);
}
return ans;
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package pplassginment;
import java.io.*;
import java.util.*;
/**
*
* @author Dark_ni8
*/
public class boysCSV
{
String name;// naam ladke ka.
double att_level;//attractiveness
double int_level;//his IQ
double budget;//his bidget
//bool isCommitted;
double min_att_lev;
boolean isCommitted;//f=comm,t=not_comm
int typ;
/**
*
* @return
* @throws FileNotFoundException
*/
public ArrayList<boys> generate()throws FileNotFoundException, IOException
//public ArrayList<boys> generate() throws IOException
{
PrintWriter pw = new PrintWriter(new File("FinalBoys.csv"));
StringBuilder sb = new StringBuilder();
ArrayList<boys> B = new ArrayList<boys>(100);
for(int i=0;i<100;i++)
{
name="BoyNo"+(i);
att_level=10+(Math.random()*19);
budget=100+(Math.random()*1000);
int_level=15+(Math.random()*25);
min_att_lev=2+(Math.random()*10);
typ=(int)1+(int)(Math.random()*3);
isCommitted=false;
sb.append(name);
sb.append(',');
sb.append(att_level);
sb.append(',');
sb.append(budget);
sb.append(',');
sb.append(int_level);
sb.append(',');
sb.append(min_att_lev);
sb.append(',');
sb.append(isCommitted);
sb.append(',');
sb.append(typ);
sb.append("\n");
//sb.append(',');
boys b = new boys(name,att_level,budget,int_level,min_att_lev,typ,isCommitted);
B.add(b);
}
pw.write(sb.toString());
pw.close();
return B;
}
}
|
package com.okellosoftwarez.modelfarm;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
import com.okellosoftwarez.modelfarm.models.userModel;
public class Profile extends AppCompatActivity implements View.OnClickListener {
Button editProfileBtn, profileUpdateBtn;
EditText dynamicProfileName, dynamicProfileMail, dynamicProfilePhone, dynamicProfileLocation;
DatabaseReference receiveProf;
userModel profileModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_profile);
Toolbar toolbarProfile = findViewById(R.id.profileToolbar);
setSupportActionBar(toolbarProfile);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setDisplayShowHomeEnabled(true);
SharedPreferences pref = getApplicationContext().getSharedPreferences("Preferences", 0);
String phone = pref.getString("phone", null);
receiveProf = FirebaseDatabase.getInstance().getReference("userProfile").child(phone);
editProfileBtn = findViewById(R.id.profileEditBtn);
profileUpdateBtn = findViewById(R.id.profileUpdateBtn);
dynamicProfileName = findViewById(R.id.dynamicProfileName);
dynamicProfileMail = findViewById(R.id.dynamicProfileMail);
dynamicProfilePhone = findViewById(R.id.dynamicProfilePhone);
dynamicProfileLocation = findViewById(R.id.dynamicProfileLocation);
receiveProf.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
profileModel = dataSnapshot.getValue(userModel.class);
dynamicProfileName.setText(profileModel.getUserName());
dynamicProfileMail.setText(profileModel.getEmail());
dynamicProfileLocation.setText(profileModel.getLocation());
dynamicProfilePhone.setText(profileModel.getPhone());
}
@Override
public void onCancelled(@NonNull DatabaseError databaseError) {
Toast.makeText(Profile.this, databaseError.getMessage(), Toast.LENGTH_SHORT).show();
}
});
profileUpdateBtn.setOnClickListener(this);
editProfileBtn.setOnClickListener(this);
}
private void submitProfileUpdate() {
String changedName, changedMail, changedLocation, phone;
changedName = dynamicProfileName.getText().toString().trim();
changedMail = dynamicProfileMail.getText().toString().trim();
changedLocation = dynamicProfileLocation.getText().toString();
phone = dynamicProfilePhone.getText().toString();
if (changedName.isEmpty()) {
dynamicProfileName.setError("Required User Name");
} else if (changedMail.isEmpty()) {
dynamicProfileMail.setError("E Mail Required");
} else if (changedLocation.isEmpty()) {
dynamicProfileLocation.setError("Location Required");
} else {
FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
user.updateEmail(changedMail)
.addOnCompleteListener(new OnCompleteListener<Void>() {
@Override
public void onComplete(@NonNull Task<Void> task) {
if (task.isSuccessful()) {
// Log.d(TAG, "User email address updated.");
Toast.makeText(Profile.this, "User email address updated.", Toast.LENGTH_SHORT).show();
}
}
});
userModel changedProfile = new userModel(changedName, changedMail, phone, changedLocation);
receiveProf.setValue(changedProfile);
updateSharedPref(changedName, changedMail, phone, changedLocation);
}
}
private void updateSharedPref(String changedName, String changedMail, String phone, String changedLocation) {
SharedPreferences pref = getApplicationContext().getSharedPreferences("Preferences", 0);
SharedPreferences.Editor editorChanged = pref.edit();
// Storing Preference Data
editorChanged.putString("eMail", changedMail);
editorChanged.putString("userName", changedName);
editorChanged.putString("phone", changedLocation);
editorChanged.putString("location", changedLocation);
// commit changes
editorChanged.commit();
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.profileUpdateBtn:
submitProfileUpdate();
dynamicProfileName.setEnabled(false);
dynamicProfileLocation.setEnabled(false);
dynamicProfileMail.setEnabled(false);
profileUpdateBtn.setVisibility(View.INVISIBLE);
editProfileBtn.setVisibility(View.VISIBLE);
break;
case R.id.profileEditBtn:
dynamicProfileName.setEnabled(true);
dynamicProfileLocation.setEnabled(true);
dynamicProfileMail.setEnabled(true);
editProfileBtn.setVisibility(View.INVISIBLE);
profileUpdateBtn.setVisibility(View.VISIBLE);
break;
}
}
}
|
package com.project.database.repository;
import com.project.database.entities.GroupEntity;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface GroupRepository extends JpaRepository<GroupEntity, Integer> {
void deleteByGroupCode(int groupId);
@Query("select distinct(g.groupName) from GroupEntity g order by g.groupName")
Page<GroupEntity> findAllByGroupName(Pageable pageable);
@Query("select distinct(g.groupName) from GroupEntity g order by g.groupName")
List<String> findAllGroupNames();
@Query("select distinct(g.eduYear) from GroupEntity g")
Page<String> findAllByEduYear(Pageable pageable);
@Query("select distinct(g.eduYear) from GroupEntity g")
List<String> findAllYears();
@Query("select distinct(g.eduYear) from GroupEntity g")
List<String> findAllGroupEduYears();
//
/******************************* ALL YOU NEED *************************************/
// @Query("SELECT distinct g.trim FROM GroupEntity g WHERE g.trim IN :semesters")
List<GroupEntity> findDistinctAllByTrimIn(@Param("semesters") List<String> semesters);
// @Query("SELECT distinct(g.course) FROM GroupEntity g WHERE g.course IN :courses")
List<GroupEntity> findDistinctAllByCourseIn(@Param("courses") List<Integer> courses);
// " select distinct(g.eduYear) from GroupEntity g where g.eduYear IN '" + eduYear + "' "
List<GroupEntity> findDistinctAllByEduYearIn(@Param("eduYears") List<String> eduYears);
List<GroupEntity> findDistinctAllByGroupNameIn(@Param("groupName") List<String> groupName);
/**********************************************************************************/
@Query("select gr " +
"from GroupEntity gr " +
"inner join SubjectEntity sub on sub.subjectNo=gr.subject.subjectNo " +
"where gr.groupName=:groupName " +
"and " +
" gr.eduYear=:eduYear " +
"and " +
" gr.trim=:trim " +
"and " +
" gr.course=:course " +
"and " +
" sub.subjectName=:subjectName ")
GroupEntity findGroupByNameYearTrimCourseSubject(
@Param("groupName") String groupName,
@Param("eduYear") String eduYear,
@Param("trim") String trim,
@Param("course") Integer course,
@Param("subjectName") String subjectName);
@Query("select gr " +
"from GroupEntity gr " +
"inner join SubjectEntity sub on gr.subject.subjectNo=sub.subjectNo " +
"where sub.subjectName=:subjectName ")
List<GroupEntity> findAllBySubjectName(@Param("subjectName") String subjectName);
@Query("select gr.groupName " +
"from GroupEntity gr " +
"inner join SubjectEntity sub on gr.subject.subjectNo=sub.subjectNo " +
"inner join VidomistEntity v on v.group.groupCode=gr.groupCode " +
"inner join TutorEntity t on t.tutorNo=v.tutor.tutorNo " +
"where " +
" t.tutorNo in (:tutorNo) " +
"and " +
" sub.subjectName in (:subjectName) ")
List<String> findAllGroupsByTeacherPIBAndSubjectName(
@Param("tutorNo") List<Integer> tutorNo,
@Param("subjectName") List<String> subjectName);
}
|
package com.github.baloise.rocketchatrestclient.util;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class Misc {
public static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'");
}
|
package de.raidcraft.skillsandeffects.pvp.skills.passive;
import de.raidcraft.skills.api.combat.EffectElement;
import de.raidcraft.skills.api.combat.EffectType;
import de.raidcraft.skills.api.exceptions.CombatException;
import de.raidcraft.skills.api.hero.Hero;
import de.raidcraft.skills.api.persistance.SkillProperties;
import de.raidcraft.skills.api.profession.Profession;
import de.raidcraft.skills.api.skill.AbstractLevelableSkill;
import de.raidcraft.skills.api.skill.SkillInformation;
import de.raidcraft.skills.api.trigger.TriggerHandler;
import de.raidcraft.skills.api.trigger.Triggered;
import de.raidcraft.skills.tables.THeroSkill;
import de.raidcraft.skills.trigger.PlayerCastSkillTrigger;
import de.raidcraft.skills.util.ConfigUtil;
import de.raidcraft.skillsandeffects.pvp.effects.buffs.damage.FlamingRageEffect;
import de.raidcraft.skillsandeffects.pvp.skills.magical.Fireball;
import org.bukkit.configuration.ConfigurationSection;
/**
* @author Silthus
*/
@SkillInformation(
name = "Flaming Rage",
description = "Verringert die Zauberzeit des nächsten Feuerzaubers nach einem Feuerball.",
types = {EffectType.MAGICAL, EffectType.BUFF, EffectType.HELPFUL},
elements = {EffectElement.FIRE}
)
public class FlamingRage extends AbstractLevelableSkill implements Triggered {
private double castDecreasePerStack = 0.20;
public FlamingRage(Hero hero, SkillProperties data, Profession profession, THeroSkill database) {
super(hero, data, profession, database);
}
@Override
public void load(ConfigurationSection data) {
castDecreasePerStack = ConfigUtil.getTotalValue(this, data.getConfigurationSection("casttime-bonus-per-stack"));
}
@TriggerHandler(ignoreCancelled = true)
public void onSkillCast(PlayerCastSkillTrigger trigger) throws CombatException {
if (trigger.getSkill().getClass() == Fireball.class) {
addEffect(FlamingRageEffect.class);
} else if (trigger.getSkill().isOfElement(EffectElement.FIRE) && hasEffect(FlamingRageEffect.class)) {
int stacks = getEffect(FlamingRageEffect.class).getStacks();
trigger.getAction().setCastTime((int) (trigger.getAction().getCastTime() - trigger.getAction().getCastTime() * castDecreasePerStack * stacks));
removeEffect(FlamingRageEffect.class);
}
}
}
|
package com.university.wanstudy.adapters;
import android.content.Context;
import android.widget.ImageView;
import android.widget.TextView;
import com.university.wanstudy.MyApp;
import com.university.wanstudy.R;
import com.university.wanstudy.model.GenreModel;
import org.xutils.x;
import java.util.List;
/**
* 专业列表适配器
*/
public class GenreAdapter extends MyBaseAdapter<GenreModel> {
public GenreAdapter(Context context, List<GenreModel> data, int... layouts) {
super(context, data, layouts);
}
@Override
public void bindData(ViewHolder holder, GenreModel genreModel) {
ImageView genreImg = (ImageView) holder.getView(R.id.genre_item_img);
//加载图片
String logoUrl = genreModel.getLogoUrl();
if (logoUrl != null) {
x.image().bind(genreImg, logoUrl, MyApp.options);
}
//设置标题
((TextView) holder.getView(R.id.genre_item_title)).setText(genreModel.getName());
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.poly.slide5;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
/**
*
* @author AnhNN
*/
public class DataOutputStreamDemo {
public static void main(String[] args) {
Student student = new Student();
student.setStudentId("ST01");
student.setName("AnhNN");
try(
ObjectOutputStream dout = new ObjectOutputStream(
new FileOutputStream("e:/Students.dat")
);
){
dout.writeObject(student);
System.out.println("Completely!");
}catch(Exception ex){
System.out.println("Error: " + ex.getMessage());
}
}
}
|
package it.datacode.tests.mongodb;
import com.google.code.morphia.annotations.Id;
import com.google.code.morphia.annotations.Indexed;
import org.apache.tapestry5.beaneditor.NonVisual;
import org.bson.types.ObjectId;
import java.math.BigDecimal;
import java.util.Date;
/**
* Created with IntelliJ IDEA.
* User: massimo
* Date: 8/2/12
* Time: 4:58 PM
* To change this template use File | Settings | File Templates.
*/
public class ElementiSezioneAreaPrivata
{
private static final long serialVersionUID = 1L;
@NonVisual @Id
private ObjectId id;
@Indexed(unique = true)
private String filename;
private String filesize;
private String filetype;
@Indexed(unique = true)
private String codice;
private String descrizione;
private String versione;
@Indexed
private String prodotto;
private BigDecimal prezzo;
private Date creato = new Date();
private Date modificato = new Date();
private boolean disabled = false;
private SottoMenuAreaPrivata sezione;
private Utente utente;
@Override
public int compareTo(ElementiSezioneAreaPrivata o)
{
int res = modificato.compareTo(o.getModificato());
if (res != 0) return res;
res = creato.compareTo(o.getCreato());
if (res != 0) return res;
return filename.compareTo(o.getFilename());
}
@Override
public String toString() {
return "ElementiSezioneAreaPrivata{" +
"filename='" + filename + '\'' +
'}';
}
}
|
package sample;
public class StudentRecord {
private String ID;
private double midterm;
private double assignments;
private double finalExam;
public StudentRecord(String ID, double midterm, double assignments, double finalExam) {
this.ID = ID;
this.midterm = midterm;
this.assignments = assignments;
this.finalExam = finalExam;
}
public String getID()
{
return this.ID;
}
public double getMidterm()
{
return this.midterm;
}
public double getAssignments()
{
return this.assignments;
}
public double getFinalExam()
{
return this.finalExam;
}
public double getFinalGrade()
{
return 0.2*this.assignments + 0.3*this.midterm + 0.5*this.finalExam;
}
}
|
package com.tencent.mm.ui.tools;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.tencent.mm.ui.tools.l.a;
class l$a$a {
TextView eGX;
ImageView gwj;
View nHH;
final /* synthetic */ a uAE;
private l$a$a(a aVar) {
this.uAE = aVar;
}
}
|
package com.fqxyi.androidtemplatetest.demo.entities;
public class DemoEntity {
}
|
package data;
import logic.model.Movie;
import logic.model.MovieRental;
import logic.repository.MovieRentalRepository;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MovieRentalController implements MovieRentalRepository {
@Override
public void createMovieRental(MovieRental movieRental) {
Connection connection = null;
PreparedStatement preparedStatement = null;
try {
connection = DriverManager.getConnection(createConnectionUrl());
preparedStatement = connection.prepareStatement("insert into video_store.movie_rentals (R_Customer_id, R_Movie_id, R_Rental_Date, R_Return_Date, R_Cost) " +
"values (?, ?, ?, ?, ?)");
preparedStatement.setInt(1, movieRental.getCustomerID());
preparedStatement.setInt(2, movieRental.getMovieID());
preparedStatement.setString(3, movieRental.getRentalDate());
preparedStatement.setString(4, movieRental.getReturnDate());
preparedStatement.setDouble(5, movieRental.getCost());
preparedStatement.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (preparedStatement != null) {
preparedStatement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
@Override
public List<MovieRental> getAllMovieRentals() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
connection = DriverManager.getConnection(createConnectionUrl());
resultSet = connection.createStatement().executeQuery("select * from video_store.movie_rentals;");
return transformToMovieRentalList(resultSet);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (resultSet != null) {
resultSet.close();
}
if (preparedStatement != null) {
preparedStatement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
return Collections.emptyList();
}
private List<MovieRental> transformToMovieRentalList(ResultSet resultSet) throws SQLException {
List<MovieRental> movieRentalList = new ArrayList<>();
while (resultSet.next()) {
MovieRental movieRental = new MovieRental();
movieRental.setId(resultSet.getInt("R_Movie_id"));
movieRental.setCustomerID(resultSet.getInt("R_Customer_id"));
movieRental.setMovieID(resultSet.getInt("R_Movie_id"));
movieRental.setRentalDate(resultSet.getString("R_Rental_Date"));
movieRental.setReturnDate(resultSet.getString("R_Return_Date"));
movieRental.setCost(resultSet.getDouble("R_Cost"));
movieRentalList.add(movieRental);
}
return movieRentalList;
}
private String createConnectionUrl() {
String host = "localhost";
String dbName = "video_store";
String user = "mike";
String password = "mike";
return "jdbc:mysql://" + host + "/" + dbName + "?" + "user=" + user + "&password=" + password + "&useSSL=false&allowPublicKeyRetrieval=true";
}
}
|
package com.lubarov.daniel.web.http.server;
import com.lubarov.daniel.common.Logger;
import com.lubarov.daniel.data.dictionary.KeyValuePair;
import com.lubarov.daniel.data.option.Option;
import com.lubarov.daniel.data.table.MutableHashTable;
import com.lubarov.daniel.data.unit.Instant;
import com.lubarov.daniel.data.util.CompressionUtils;
import com.lubarov.daniel.web.http.ContentEncoding;
import com.lubarov.daniel.web.http.DateUtils;
import com.lubarov.daniel.web.http.HttpRequest;
import com.lubarov.daniel.web.http.HttpResponse;
import com.lubarov.daniel.web.http.RequestMethod;
import com.lubarov.daniel.web.http.compression.AcceptEncodingParser;
import com.lubarov.daniel.web.http.cookies.CookieManager;
import com.lubarov.daniel.web.http.websocket.AcceptKeyGenerator;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
// TODO: Split this logic up more.
final class ConnectionManager implements Runnable {
private static final Logger logger = Logger.forClass(ConnectionManager.class);
private final Socket socket;
private final Handler handler;
private final Option<WebSocketHandler> webSocketHandler;
public ConnectionManager(Socket socket, Handler handler,
Option<WebSocketHandler> webSocketHandler) {
this.socket = socket;
this.handler = handler;
this.webSocketHandler = webSocketHandler;
}
@Override
public void run() {
try {
runWithExceptions();
} catch (Exception e) {
logger.error(e, "Exception in connection management.");
}
}
private void runWithExceptions() throws IOException {
Option<HttpRequest> optRequest = RequestReader.readRequest(socket.getInputStream());
if (optRequest.isEmpty()) {
logger.debug("Received empty request.");
return;
}
HttpRequest request = optRequest.getOrThrow();
boolean upgrade = request.getHeaders().getValues("Connection").contains("Upgrade");
boolean websocket = upgrade && request.getHeaders().getValues("Upgrade").contains("websocket");
if (websocket)
handleWebsocketRequest(request);
else
handleNormalRequest(request);
}
private void handleWebsocketRequest(HttpRequest request) throws IOException {
if (webSocketHandler.isEmpty())
throw new RuntimeException("No WebSocket handler configured.");
logger.info("Handling WebSocket request for %s%s.", request.getHost(), request.getResource());
String clientKey = request.getHeaders().getValues("Sec-WebSocket-Key")
.tryGetOnlyElement().getOrThrow("Expected exactly one websocket key.");
String accept = AcceptKeyGenerator.generateAcceptKey(clientKey);
Writer writer = new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.US_ASCII);
writer.write("HTTP/1.1 101 Switching Protocols\r\n");
writer.write("Upgrade: websocket\r\n");
writer.write("Connection: Upgrade\r\n");
writer.write("Sec-WebSocket-Accept: " + accept + "\r\n");
writer.write("\r\n");
writer.flush();
new WebSocketManager(request, socket, webSocketHandler.getOrThrow()).listen();
}
private void handleNormalRequest(HttpRequest request) throws IOException {
Writer writer = new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.US_ASCII);
logger.info("Handling %s request for %s%s.", request.getHttpVersion(), request.getHost(), request.getResource());
logger.info("User agents: %s.", request.getHeaders().getValues("User-Agent"));
logger.info("All headers: %s.", request.getHeaders());
CookieManager.resetCookies();
HttpResponse response = handler.handle(request);
// TODO: This breaks header order, which is okay but not ideal.
MutableHashTable<String, String> responseHeaders =
MutableHashTable.copyOf(response.getHeaders());
boolean gzipAccepted = AcceptEncodingParser.getAcceptedEncodings(request.getHeaders()).contains("gzip");
String defaultContentEncoding = gzipAccepted ? "gzip" : "identity";
String contentEncodingString = responseHeaders.getValues("Content-Encoding")
.tryGetOnlyElement().getOrDefault(defaultContentEncoding);
final ContentEncoding contentEncoding = ContentEncoding.valueOf(contentEncodingString.toUpperCase());
Option<byte[]> encodedContent = response.getBody().map(rawContent -> {
switch (contentEncoding) {
case IDENTITY:
return rawContent;
case GZIP:
return CompressionUtils.gzip(rawContent);
default:
throw new AssertionError("Unexpected content encoding: " + contentEncoding);
}
});
if (!responseHeaders.containsKey("Server"))
responseHeaders.put("Server", "daniel");
if (!responseHeaders.containsKey("Date"))
responseHeaders.put("Date", DateUtils.formatRfc1123(Instant.now()));
if (!responseHeaders.containsKey("Content-Encoding") && contentEncoding != ContentEncoding.IDENTITY)
responseHeaders.put("Content-Encoding", contentEncoding.name().toLowerCase());
if (!responseHeaders.containsKey("Vary"))
responseHeaders.put("Vary", "Accept-Encoding");
if (encodedContent.isDefined() && !responseHeaders.containsKey("Content-Length"))
responseHeaders.put("Content-Length", Integer.toString(encodedContent.getOrThrow().length));
if (!responseHeaders.containsKey("Connection"))
responseHeaders.put("Connection", "close");
// Write headers.
writer.write(String.format("HTTP/%s %s\r\n", response.getHttpVersion(), response.getStatus()));
for (KeyValuePair<String, String> header : responseHeaders)
writer.write(String.format("%s: %s\r\n", header.getKey(), header.getValue()));
writer.write("\r\n");
writer.flush();
// Write body.
if (encodedContent.isDefined() && request.getMethod() != RequestMethod.HEAD)
socket.getOutputStream().write(encodedContent.getOrThrow());
socket.close();
}
}
|
package com.example.quizapp;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
import java.util.List;
public class Database extends SQLiteOpenHelper{
private static final String DATABASE_FILE_NAME = "saved_news";
public Database(Context context){super(context, DATABASE_FILE_NAME, null, 1);}
@Override
public void onCreate(SQLiteDatabase db) {
String query = String.format(
"CREATE TABLE IF NOT EXISTS %s (%s INTEGER PRIMARY KEY AUTOINCREMENT, %s TEXT, %s TEXT, %s TEXT, %s TEXT)",
ResultsModel.TABLE_NAME, ResultsModel.FIELD_RESULT_ID, ResultsModel.FIELD_USERNAME, ResultsModel.FIELD_NUMBER, ResultsModel.FIELD_DIFFICULTY, ResultsModel.FIELD_POINTS
);
db.execSQL(query);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(String.format("DROP TABLE IF EXISTS %s", ResultsModel.TABLE_NAME));
onCreate(db);
}
public void addResult (String username, String number, String difficulty, String points){
SQLiteDatabase db = this.getWritableDatabase();
ContentValues cv = new ContentValues();
cv.put(ResultsModel.FIELD_USERNAME, username);
cv.put(ResultsModel.FIELD_NUMBER, number);
cv.put(ResultsModel.FIELD_DIFFICULTY, difficulty);
cv.put(ResultsModel.FIELD_POINTS, points);
db.insert(ResultsModel.TABLE_NAME, null, cv);
}
public int deleteResults(int resultId){
SQLiteDatabase db = this.getWritableDatabase();
return db.delete(ResultsModel.TABLE_NAME,ResultsModel.FIELD_RESULT_ID + " = ?", new String[] {String.valueOf(resultId)});
}
public List<ResultsModel> getAllSavedResults(){
SQLiteDatabase db = this.getReadableDatabase();
String query = String.format("SELECT * FROM %s", ResultsModel.TABLE_NAME);
Cursor result = db.rawQuery(query, null);
result.moveToFirst();
List<ResultsModel> list = new ArrayList<>(result.getCount());
while (!result.isAfterLast()){
int resultId = result.getInt(result.getColumnIndex(ResultsModel.FIELD_RESULT_ID));
String username = result.getString(result.getColumnIndex(ResultsModel.FIELD_USERNAME));
String number = result.getString(result.getColumnIndex(ResultsModel.FIELD_NUMBER));
String difficulty = result.getString(result.getColumnIndex(ResultsModel.FIELD_DIFFICULTY));
String points = result.getString(result.getColumnIndex(ResultsModel.FIELD_POINTS));
ResultsModel post = new ResultsModel(resultId, username, number, difficulty, points);
list.add(post);
result.moveToNext();
}
return list;
}
}
|
/*
* created 28.10.2005
*
* Copyright 2009, ByteRefinery
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* $Id: IndexNode.java 664 2007-09-28 17:28:39Z cse $
*/
package com.byterefinery.rmbench.export.diff.db;
import com.byterefinery.rmbench.RMBenchPlugin;
import com.byterefinery.rmbench.export.diff.DiffUtils;
import com.byterefinery.rmbench.export.diff.IComparisonNode;
import com.byterefinery.rmbench.external.IDDLGenerator;
import com.byterefinery.rmbench.external.IDDLScript;
import com.byterefinery.rmbench.model.Model;
import com.byterefinery.rmbench.model.dbimport.DBIndex;
import com.byterefinery.rmbench.model.schema.Column;
import com.byterefinery.rmbench.model.schema.Table;
import com.byterefinery.rmbench.operations.AddIndexOperation;
import com.byterefinery.rmbench.operations.RMBenchOperation;
import com.byterefinery.rmbench.util.ImageConstants;
/**
* @author cse
*/
class IndexNode extends DBValueNode {
private final DBIndex index;
protected IndexNode(DBIndex index) {
super(index.name, RMBenchPlugin.getImage(ImageConstants.INDEX));
this.index = index;
}
public Object getElement() {
return index;
}
public void generateDropDDL(IDDLGenerator generator, IDDLScript script) {
script.beginStatementContext();
generator.dropIndex(index.getIIndex(), script);
setStatementContext(script.endStatementContext());
}
protected String generateValue(boolean ignoreCase) {
return DiffUtils.generateIndexValue(
index.name,
index.unique,
index.getColumnNames(),
index.getAscending(),
ignoreCase);
}
public String getNodeType() {
return IComparisonNode.INDEX;
}
public RMBenchOperation newAddToModelOperation(Model model) {
Table table = model.findTable(index.table.getSchemaName(), index.table.getName());
String[] colNames = index.getColumnNames();
Column[] columns = new Column[colNames.length];
for (int i=0; i<columns.length; i++) {
columns[i] = table.getColumn(colNames[i]);
}
return new AddIndexOperation(index.name, columns, table, index.unique, index.getAscending());
}
}
|
package classes;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import com.example.medicalprocess.MainActivity;
public class Stade {
private int sid;
private Maladie maladie;
private Phase phase;
private int stade;
public int getSid() {
return this.sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public Maladie getMaladie() {
return this.maladie;
}
public void setMaladie(Maladie maladie) {
this.maladie = maladie;
}
public Phase getPhase() {
return this.phase;
}
public void setPhase(Phase phase) {
this.phase = phase;
}
public int getStade() {
return this.stade;
}
public void setStade(int stade) {
this.stade = stade;
}
public Stade(ResultSet rs) throws SQLException {
sid = rs.getInt("sid");
maladie = Maladie.getByMid(rs.getInt("maladie"));
phase = Phase.getByPid(rs.getInt("phase"));
stade = rs.getInt("stade");
}
public Stade[] autresAlternatives() {
throw new UnsupportedOperationException();
}
public Stade stadeSuivant() throws SQLException {
Statement statement = MainActivity.connexion.createStatement();
ResultSet rs = statement.executeQuery("SELECT * FROM Stades WHERE mid = '"+maladie+"' AND stade = "+(stade+1));
if(rs.next())
return new Stade(rs);
return null;
}
public Stade stadePrecedent() throws SQLException {
Statement statement = MainActivity.connexion.createStatement();
ResultSet rs = statement.executeQuery("SELECT * FROM Stades WHERE mid = '"+maladie+"' AND stade = "+(stade-1));
if(rs.next())
return new Stade(rs);
return null;
}
public static Stade getBySid(int sid) throws SQLException
{
Statement statement = MainActivity.connexion.createStatement();
ResultSet rs = statement.executeQuery("SELECT * FROM Stades WHERE sid = '"+sid+"'");
if(rs.next())
return new Stade(rs);
return null;
}
public static List<Stade> getListByPatient(int pid) throws SQLException
{
List<Stade> result = new ArrayList<Stade>();
Statement statement = MainActivity.connexion.createStatement();
ResultSet rs = statement.executeQuery("SELECT S.sid AS sid FROM Stades S, Patients_Stades PS WHERE S.sid = PS.sid AND PS.pid = '"+pid+"'");
while(rs.next())
{
result.add(Stade.getBySid(rs.getInt("sid")));
}
return result;
}
}
|
import java.util.Arrays;
import java.util.Iterator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class MixStream {
public static <A> Stream<A> zip(Stream<A> first, Stream<A> second) {
Iterator<A> firstIterator = first.iterator();
Iterator<A> secondIterator = second.iterator();
Stream<A> mixingStream = Stream.empty();
while (firstIterator.hasNext() & ((Iterator<?>) secondIterator).hasNext()){
mixingStream = Stream.concat(mixingStream, Stream.of(firstIterator.next(),
secondIterator.next()));
}
return mixingStream;
}
public static void main(String[] args) {
System.out.println(MixStream.zip(Arrays.stream(new String[]{"1", "2" ,"3", "4", "5"}),
Arrays.stream(new String[]{"ONE", "TWO", "THREE", "FOUR", "FIVE"}))
.collect(Collectors.joining(" ")));
}
}
|
package mx.org.ift.ntp.service;
import java.sql.Timestamp;
public interface NtpService {
public Timestamp getTime(String url);
}
|
package com.ls.Test.packages.p4;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
System.out.println("請輸入年月日");
int year = s.nextInt();
int mouth = s.nextInt();
int day = s.nextInt();
int sumDays = getSumDay(year,mouth,day);
System.out.println(year+"年"+mouth+"月"+day+"日"+"是這一年的第"+sumDays+"天");
}
private static int getSumDay(int year, int mouth, int day) {
// TODO Auto-generated method stub
int days = 0;
for (int i = 1; i < mouth; i++) {
days += getMouthDay(year,i);
}
return days+day;
}
private static int getMouthDay(int year, int mouth) {
// TODO Auto-generated method stub
switch (mouth) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
return 31;
case 4:
case 6:
case 9:
case 11:
return 30;
default:
if (year%4==0&&year%100!=0||year%400 ==0) {
return 29;
}else {
return 28;
}
}
}
}
|
package dbreader;
import java.io.File;
import Conversion.Reformatgzip;
/**
* Final procedure of merging. For each data directory, we will first call the reformatgzip class
* and the reformat method to reformat our gzip files to .dat files with desired fields.
* Then we will do iterative merge where we merge all the _1.dat files to _2.dat files 2 or 3 at a time
* until we have no more files to merge.
* @author senongtor
*
*/
public class Mergeall {
static final String ADDRESS="/Users/senongtor/Downloads/sampleTAQ2/trades/";
//CHANGE THIS ADDRESS ACCORDINGLY
public static void main(String[] args){
File _dir = new File(ADDRESS);
File[] directoryListing = _dir.listFiles();
if (directoryListing != null && _dir.isDirectory()) {
for (File child : directoryListing) {
//We need to ignore ds_store files.
// if (child.getAbsolutePath().toLowerCase().endsWith(".ds_store"));
// {continue;}
if(!child.isDirectory()){
continue;
}
System.out.println(child.getAbsolutePath());
Reformatgzip.reformat(child);
}
System.out.println("Written to memory and Reformation is finished!");
for(File child : directoryListing){
try {
Mergeiterative merge=new Mergeiterative(child);
merge.mergeandupdate();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("Merging finished! Check your directory!");
}
}
}
|
package com.mrhan.db.entitydaos.keytype;
import java.lang.annotation.*;
/**
* 自动增长键
*/
@Inherited
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoKey {
}
|
package javax.swing;
import java.util.HashMap;
public abstract class AbstractAction implements Action {
boolean enabled;
private HashMap<String, Object> values = new HashMap<String, Object>();
public void putValue(String key, Object value) {
values.put(key, value);
}
public Object getValue(String key) {
return values.get(key);
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public AbstractAction() {
//this.NAME = "";
}
public AbstractAction(String name) {
//this.NAME = name;
}
public AbstractAction(String name, Icon icon) {
//this.NAME = name;
}
}
|
package listexer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
//随机存十个数，反转输出、从大到小输出
public class exercise1 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add((int) (Math.random() * 100 + 1));
}
System.out.println(list);
/*
* Collections.reverse(list); System.out.println(list);
*/
Collections.sort(list);
System.out.println(list);
System.out.println();
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(list);
}
}
|
package br.com.tomioka.vendashortalicas.services;
import br.com.tomioka.vendashortalicas.dto.ProdutoDto;
import br.com.tomioka.vendashortalicas.models.Produto;
import br.com.tomioka.vendashortalicas.repositories.ProdutoRepository;
import org.assertj.core.internal.bytebuddy.implementation.bind.annotation.Argument;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
class ProdutoServiceTest {
private ProdutoService service;
private List<Produto> produtos;
@Mock
private ProdutoRepository produtoRepository;
@Captor
private ArgumentCaptor<Produto> captor;
@BeforeEach
public void setUp() {
MockitoAnnotations.openMocks(this);
this.service = new ProdutoService(produtoRepository);
this.produtos = produtos();
}
@Test
void deveriaListarTodosOsProdutosDoRepositorio() {
when(produtoRepository.findAll()).thenReturn(produtos);
List<Produto> produtosMock = service.findAll();
assertEquals(produtos.get(0).getNome(), produtosMock.get(0).getNome());
assertEquals(produtos.get(1).getNome(), produtosMock.get(1).getNome());
assertEquals(produtos.get(2).getNome(), produtosMock.get(2).getNome());
}
@Test
void deveriaEfetuarUmaBuscaPorId() {
Long id = 1L;
when(produtoRepository.findById(id))
.thenReturn(Optional.ofNullable(produtos.get(0)));
Optional<Produto> produtoMock = service.find(id);
assertEquals(produtos.get(0).getId(), produtoMock.get().getId());
assertEquals(produtos.get(0).getNome(), produtoMock.get().getNome());
}
@Test
void deveriaSalvarUmNovoProduto() {
ProdutoDto dto = new ProdutoDto("Salsa", new BigDecimal("1.50"));
service.save(dto);
verify(produtoRepository).save(captor.capture());
Produto produto = captor.getValue();
assertEquals(dto.getNome(), produto.getNome());
}
private List<Produto> produtos() {
List<Produto> lista = new ArrayList<>();
lista.add(new Produto(1L, "Alface Americana", new BigDecimal("2")));
lista.add(new Produto(2L, "Couve Manteiga", new BigDecimal("1.5")));
lista.add(new Produto(3L, "Brocolis", new BigDecimal("4")));
return lista;
}
}
|
public class Trab2{
public static void main(String[] args){
int op;
do{
System.out.println("MENU PRINCIPAL");
System.out.println("1- Consultar saldo");
System.out.println("2- Efetuar saque");
System.out.println("3- Efetuar depósito");
System.out.println("4- Efetuar transferência");
System.out.println("5- Exibir dados da conta");
System.out.println("6- Sair");
switch(op){
case 1:
ChecaSaldo();
break;
case 2:
Depositar();
break;
case 3:
Sacar();
break;
case 4:
Transfer();
break;
case 5:
ExibirDados();
break;
}
}while(op!=6);
}
|
package com.datastax.banking.service;
import java.util.List;
import com.datastax.banking.dao.BankDao;
import com.datastax.banking.model.Account;
import com.datastax.banking.model.Atm;
import com.datastax.banking.model.Bank;
import com.datastax.banking.model.Branch;
import com.datastax.banking.model.Permission;
import com.datastax.banking.model.Product;
import com.datastax.banking.model.Transaction;
import com.datastax.banking.model.User;
import com.datastax.demo.utils.PropertyHelper;
public class BankService {
private static String contactPointsStr = PropertyHelper.getProperty("contactPoints", "localhost");
private static BankService bankService = new BankService();
private BankDao dao;
private BankService() {
dao = new BankDao(contactPointsStr.split(","));
}
public static BankService getInstance() {
return bankService;
}
public List<Transaction> getTransactions(String accountId) {
return dao.getTransactions(accountId);
}
public Transaction getTransaction(String transactionId) {
return dao.getTransaction(transactionId);
}
public void saveBranches(List<Branch> branches) {
for (Branch branch : branches) {
this.dao.saveBranch(branch);
}
}
public void saveBranch(Branch branch) {
this.dao.saveBranch(branch);
}
public void saveBank(Bank bank) {
this.dao.saveBank(bank);
}
public void saveAtm(Atm atm) {
this.dao.saveAtm(atm);
}
public void saveTransacton(Transaction transaction) {
this.dao.saveTransaction(transaction);
}
public void saveProduct(Product product) {
this.dao.saveProduct(product);
}
public void saveAccount(Account account) {
this.dao.saveAccount(account);
}
public void saveUser(User user) {
this.dao.saveUser(user);
}
public void savePermission(Permission permission) {
this.dao.savePermission(permission);
}
}
|
// Práctica 2: SQL y Java
// Autoras: Ana María Casado Faulí - Matrícula: 20A003
// Alicia Germán Bellod - Matrícula: 20A059
package series;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
// En esta clase se encontrarán primero las funciones públicas que se pidieron
// en el enunciado de la práctica, en el orden original y luego se tienen las
// funciones privadas que se utilizan en las primeras.
public class SeriesDatabase {
// La conexión a la base de datos se declara como miembro estático de la clase
// para asegurar que será un objeto único que podremos utilizar a lo largo de la ejecución.
// Además se ha declarado como privado para evitar el acceso desde el exterior.
private static Connection conn_ = null;
// Constructor vacío.
public SeriesDatabase() {}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////FUNCIONES PÚBLICAS///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
/////////////////////FUNCIÓN 1: OPEN CONNECTION/////////////////////
////////////////////////////////////////////////////////////////////
// Función encargada de abrir la conexión con la base de datos.
// Este método se llamará en el resto de las funciones que requieran
// acceso a la base de datos para asegurar que existe.
// Devuelve true si la conexión se realiza y false si no se realiza
// o si ya se encontraba abierta.
public boolean openConnection() {
if(conn_ == null) { // Si la conexión está cerrada.
try { // Intentamos cargar el driver
String drv = "com.mysql.cj.jdbc.Driver";
Class.forName(drv);
System.out.println("[INFO] Driver cargado correctamente");
} catch (ClassNotFoundException _e){
System.err.println("[EXCEPTION] Error, el driver no se ha encontrado");
_e.printStackTrace();
return false;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado " + _e.getMessage());
return false;
}
try { // Intentamos abrir la base de datos
String serverAddress = "localhost:3306";
String db = "series";
String user = "series_user";
String pass = "series_pass";
String url = "jdbc:mysql://" + serverAddress + "/" + db;
conn_ = DriverManager.getConnection(url, user, pass);
System.out.println("[INFO] Base de Datos cargada correctamente");
return true;
}catch (SQLException _e) {
conn_ = null; // para asegurar que la conexión no exista
System.err.println("[EXCEPTION] Error, la base de datos no se ha encontrado");
return false;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado " + _e.getMessage());
return false;
}
}else { // Si la conexión ya estaba abierta
System.out.println("[WARNING] Base de Datos cargada anteriormente");
return false;
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////FUNCIÓN 2: CLOSE CONNECTION/////////////////////
/////////////////////////////////////////////////////////////////////
// Función que cierra la conexión. Devuelve true si se cierra o
// si ya se encontraba cerrada. Devuelve false si hay alguna excepción.
public boolean closeConnection() {
if(conn_ != null) { // Si la conexión está abierta
try { // Intentamos cerrar la conexión
conn_.close();
conn_ = null;
System.out.println("[INFO] Base de Datos cerrada correctamente");
return true;
} catch(SQLException _e) {
System.err.println("[EXCEPTION] Error, error cerrando la conexión");
return false;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado " + _e.getMessage());
return false;
}
}else { // Si la conexión ya estaba cerrada
System.out.println("[WARNING] La conexión ya se encontraba cerrada");
return true;
}
}
//////////////////////////////////////////////////////////////////////////
/////////////////////FUNCIÓN 3: CREATE TABLE CAPITULO/////////////////////
//////////////////////////////////////////////////////////////////////////
// Creación de la tabla capítulo.
// Devuelve false si la tabla no se ha podido crear (por algún tipo de error o porque
// ya existiese) y true si la tabla se ha creado correctamente.
public boolean createTableCapitulo() {
// Query SQL en formato String
// La PK de capítulo tiene las PK de serie y temporada
// (que por construcción existen ambas en temporada).
// Las actualizaciones se hacen en cascada tanto para
// borrado como en actualización.
String query = "CREATE TABLE capitulo (" +
"n_orden INT, " +
"titulo VARCHAR(100), " +
"duracion INT, " +
"fecha_estreno DATE, " +
"id_serie INT, " +
"n_temporada INT, " +
"PRIMARY KEY (id_serie, n_temporada, n_orden), " +
"FOREIGN KEY (id_serie, n_temporada) REFERENCES temporada (id_serie, n_temporada) " +
"ON DELETE CASCADE ON UPDATE CASCADE);";
// Esta función se encarga de la creación completa de la tabla y devuelve lo mismo
// que debe devolver esta función.
return handleTableCreation(query, "capitulo");
}
////////////////////////////////////////////////////////////////////////
/////////////////////FUNCIÓN 4: CREATE TABLE VALORA/////////////////////
////////////////////////////////////////////////////////////////////////
// Creación de la tabla valora.
// Devuelve false si la tabla no se ha podido crear (por algún tipo de error o porque
// ya existiese) y true si la tabla se ha creado correctamente.
public boolean createTableValora() {
// Query SQL en formato String
// La PK que viene de capítulo tiene las PK de serie y temporada.
// Las actualizaciones se hacen en cascada tanto para
// borrado como en actualización.
String query = "CREATE TABLE valora (" +
"id_serie INT, " +
"n_temporada INT, " +
"n_orden INT, " +
"id_usuario INT, " +
"valor INT, " +
"fecha DATE, " +
"PRIMARY KEY (id_serie, n_temporada, n_orden, id_usuario, fecha), " +
"FOREIGN KEY (id_serie, n_temporada, n_orden) REFERENCES capitulo (id_serie, n_temporada, n_orden) " +
"ON DELETE CASCADE ON UPDATE CASCADE," +
"FOREIGN KEY (id_usuario) REFERENCES usuario (id_usuario) " +
"ON DELETE CASCADE ON UPDATE CASCADE);";
// Esta función se encarga de la creación completa de la tabla y devuelve lo mismo
// que debe devolver esta función.
return handleTableCreation(query, "valora");
}
//////////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 5: LOAD CAPITULOS/////////////////////
//////////////////////////////////////////////////////////////////
// Función que inserta las tuplas que vienen definidas en el archivo que se pasa
// como parámetro. Devuelve la cantidad de elementos insertados en la tabla.
public int loadCapitulos(String fileName) {
// Función que se encarga de la gestión de los datos y devuelve lo mismo.
return loadDataToTable(fileName, "capitulo");
}
/////////////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 6: LOAD VALORACIONES/////////////////////
/////////////////////////////////////////////////////////////////////
// Función que inserta las tuplas que vienen definidas en el archivo que se pasa
// como parámetro. Devuelve la cantidad de elementos insertados en la tabla.
public int loadValoraciones(String fileName) {
// Función que se encarga de la gestión de los datos y devuelve lo mismo.
return loadDataToTable(fileName, "valora");
}
////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 7: CATALOGO/////////////////////
////////////////////////////////////////////////////////////
// Este método retorna una cadena de caracteres que contiene
// una lista con el nombre de cada una de las series seguidos
// del número de episodios de cada una de sus temporadas.
// El orden de las series será creciente según su ID_serie y,
// dentro de cada una de ellas, en número de capítulos de cada
// temporada se ordenará en orden creciente del número de
// temporada a la que pertenezcan. Si ocurre alguna excepción
// se retorna null.
public String catalogo() {
openConnection(); // Comprobamos la conexión
if(conn_ != null) { // Si la conexión está abierta
String seriesYTemps = "{";
Statement st = null;
ResultSet rs = null;
// Mostramos los títulos y el número de capítulos. las tablas serie y título se conectan
// mediante un left join a través del identificador de la serie.
String query = "SELECT s.titulo, t.n_capitulos " +
"FROM serie s LEFT JOIN temporada t ON s.id_serie=t.id_serie " +
"ORDER BY s.id_serie ASC, t.n_temporada ASC;";
try {
st = conn_.createStatement();
rs = st.executeQuery(query);
String tituloOld = "";
boolean primeraTupla = true;
boolean primeraTemp = true;
// Hasta que no lleguemos al final de las tuplas y aquí
// halla un null, se realizará este bucle.
while(rs.next()) {
String titulo = rs.getString("titulo");
int capitulosTemp = rs.getInt("n_capitulos");
// Comparamos el título de la serie de la tupla actual con el de
// la anterior para asegurarnos de que añadimos un determinado
// número de capítulos a la serie que le corresponde
if(!tituloOld.equals(titulo)) {
if(!primeraTupla) {
seriesYTemps += "],";
}
seriesYTemps += titulo + ":[";
primeraTupla = false;
primeraTemp = true;
}
// Añadimos el número de capítulos si es
// distinto de cero
if(capitulosTemp !=0) {
if(!primeraTemp) {
seriesYTemps += ",";
}
String ctString = Integer.toString(capitulosTemp);
seriesYTemps += ctString;
primeraTemp = false;
}
tituloOld = titulo;
}
// Condición para añadir corchete al último elemento
// si ha habido algo introducido a la string
if(!seriesYTemps.equals("{")) seriesYTemps += "]";
seriesYTemps += "}";
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Problemas con la Statement");
seriesYTemps = null;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage());
seriesYTemps = null;
} finally {
try {
// Cerramos todo lo necesario
if(st != null) st.close();
if(rs != null) rs.close();
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el Statement");
seriesYTemps = null;
}
}
return seriesYTemps;
}else {
System.err.println("[ERROR] No hay conexion abierta");
return null;
}
}
////////////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 8: NO HAN COMENTADO/////////////////////
////////////////////////////////////////////////////////////////////
// El siguiente método devuelve una lista con los nombres y apellidos
// de los usuarios que no han comentado ninguna serie. Si ocurre alguna
// excepción se retorna null.
public String noHanComentado() {
openConnection(); // Comprobamos la conexión
if(conn_ != null) { // Si la conexión está abierta
// Los elementos han de estar ordenados alfabéticamente por el
// primer apellido, en caso de empate, por el segundo y, en
// caso de empate, por el nombre
String query = "SELECT u.nombre, u.apellido1, u.apellido2 " +
"FROM usuario u LEFT JOIN comenta c ON u.id_usuario=c.id_usuario " +
"WHERE c.texto IS NULL " +
"ORDER BY u.apellido1 ASC, u.apellido2 ASC, u.nombre ASC;";
Statement st = null;
ResultSet rs = null;
String noCommentUsers = "[";
try {
st = conn_.createStatement();
rs = st.executeQuery(query); // Ejecutamos la query y recogemos el resultado
boolean primeraTupla = true;
while(rs.next()) { // Hasta que no halla elementos en el resultado
if(!primeraTupla) {
// Si no es el primer usuario de la lista de individuos que no
// han comentado, lo separamos del anterior con una coma
noCommentUsers += ", ";
}
String nombre = rs.getString("nombre");
String apellido1 = rs.getString("apellido1");
String apellido2 = rs.getString("apellido2");
noCommentUsers += nombre + " " + apellido1 + " " + apellido2;
primeraTupla = false;
}
noCommentUsers += "]";
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Problemas con la Statement");
noCommentUsers = null;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage());
noCommentUsers = null;
} finally {
try {
if(st != null) st.close();
if(rs != null) rs.close();
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el Statement");
noCommentUsers = null;
}
}
return noCommentUsers;
}else { // Si no hay conexión abierta
System.err.println("[ERROR] No hay conexion abierta");
return null;
}
}
////////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 9: MEDIA GENERO/////////////////////
////////////////////////////////////////////////////////////////
// Este método devuelve la valoración media de los capítulos que
// pertenezcan a una serie en cuya descripción figure el género
// que se pasa como String del parámetro del método.
public double mediaGenero(String genero) {
openConnection(); // Comprobamos la conexión
if(conn_ != null) { // Si la conexión está abierta
// Hacemos dos queries: la primera (query1) nos permite pasar el
// género como string al método. La segunda (query2) da el valor
// medio solicitado. El tercer inner join se hace considerando las
// tuplas en las que la misma combinación de los atributos
// id_serie, n_orden, n_temporada esté presente en las tablas capitulo
// y valora
String query1 = "SELECT descripcion FROM genero WHERE descripcion = ?;";
String query2 = "SELECT AVG(v.valor) AS media " +
"FROM capitulo c " +
"INNER JOIN pertenece p ON c.id_serie=p.id_serie " +
"INNER JOIN genero g ON p.id_genero=g.id_genero " +
"INNER JOIN valora v ON (c.id_serie, c.n_orden, c.n_temporada) = (v.id_serie, v.n_orden, v.n_temporada) " +
"WHERE g.descripcion = ?;";
PreparedStatement pst1 = null;
PreparedStatement pst2 = null;
ResultSet rs1 = null;
ResultSet rs2 = null;
double media = -1.0;
try {
pst1 = conn_.prepareStatement(query1); // Preparamos la query1
pst1.setString(1, genero);
rs1 = pst1.executeQuery(); // Ejecutamos la query1
if(!rs1.next()) {
// Si el género introducido como parámetro
// en el método no existe, se devuelve un -1
media = -1.0;
}else {
pst2 = conn_.prepareStatement(query2); // Preparamos la query2
pst2.setString(1, genero);
rs2 = pst2.executeQuery(); // Ejecutamos la query2
if(rs2.next()) {
media = rs2.getDouble("media"); // Recogemos el valor devuelto
}else {
// Si no hay ningún capítulo dentro del género
// solicitado y pero el género existe en la BBDD,
// se devuelve un 0
media = 0.0;
}
}
//Siempre que se genere alguna excepción o error, se devolverá un -2
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Problemas con la Statement");
media = -2.0;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage());
media = -2.0;
} finally {
try {
// Cerramos todo lo necesario
if(pst1 != null) pst1.close();
if(rs1 != null) rs1.close();
if(pst2 != null) pst2.close();
if(rs2 != null) rs2.close();
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el Statement");
media = -2.0;
}
}
return media;
}else { // Si no hay conexión
System.err.println("[ERROR] No hay conexion abierta");
return -2.0;
}
}
///////////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 10: DURACION MEDIA/////////////////////
///////////////////////////////////////////////////////////////////
// Este método debe retornar la duración media de aquellos capítulos
// que pertenezcan a una serie que esté en un determinado idioma
// (el cual se pasa como parámetro) y que no hayan recibido ninguna
// valoración por parte de los usuarios.
public double duracionMedia(String idioma) {
openConnection(); // Comprobamos la conexión
if(conn_ != null) { // Si la conexión está abierta
// Los capítulos pueden no tener valoraciones, por lo que se
// hace el left join que vemos a continuacion, de forma que
// se obtengan tanto aquellos capítulos valorados como aquellos
// que no. Para que la unión se realice correctamente,
// se considera como conector aquel formado por los
// tres atributos que constituyen la PK de capítulo:
// d_serie, n_orden y n_temporada
String query = "SELECT AVG(c.duracion) AS media " +
"FROM capitulo c " +
"INNER JOIN serie s ON c.id_serie = s.id_serie " +
"LEFT JOIN valora v ON (c.id_serie, c.n_orden, c.n_temporada) = (v.id_serie, v.n_orden, v.n_temporada) " +
"WHERE s.idioma = ? AND v.valor IS NULL;";
PreparedStatement pst = null;
ResultSet rs = null;
double media = -1.0;
try {
pst = conn_.prepareStatement(query); // Preparamos la query
pst.setString(1, idioma);
rs = pst.executeQuery(); // Ejecutamos la query
if(!rs.next() || rs.getDouble("media") == 0) {
// Si no hay capítulos que cumplan con las condiciones
// y el género por el que se ha preguntado existe en la
// base de datos, se devuelve un -1
media = -1.0;
}else {
media = rs.getDouble("media"); // Recogemos el resultado
}
//Si se produce una excepción, se retorna un -2
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Problemas con la Statement");
media = -2.0;
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage());
media = -2.0;
} finally {
try {
// Cerramos lo necesario
if(pst != null) pst.close();
if(rs != null) rs.close();
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el Statement");
media = -2.0;
}
}
return media;
}else { // Si la conexión está cerrada
System.err.println("[ERROR] No hay conexion abierta");
return -2.0;
}
}
/////////////////////////////////////////////////////////////
////////////////////FUNCIÓN 11: SET FOTO/////////////////////
/////////////////////////////////////////////////////////////
// Este método añade una foto contenida en el fichero cuyo nombre
// se pasa como parámetro al usuario cuyo primer apellido es
// 'Cabeza'. Devuelve true si se añade la foto y false si no se
// añade debido a excepciones, que el usuario ya tuviese una foto,
// que haya más de un usuario de apellido 'Cabeza' o que no haya nunguno.
public boolean setFoto(String filename) {
openConnection();
if(conn_ != null) {
// Se cuenta el número de usuarios que tienen como primer apellido
// 'Cabeza'.
String query1 = "SELECT COUNT(nombre) AS cuenta " +
"FROM usuario " +
"WHERE apellido1 = 'Cabeza';";
// Se nos especifica que, una de las condiciones para que la inserción
// de la foto se realice, es que no haya ya una foto en el lugar donde
// queremos insertarla
String query2 = "UPDATE usuario " +
"SET fotografia = ? " +
"WHERE apellido1 = 'Cabeza' AND fotografia IS NULL;";
PreparedStatement pst = null;
Statement st = null;
ResultSet rs = null;
boolean success = false;
try {
st = conn_.createStatement();
rs = st.executeQuery(query1);
rs.next();
// Otra condición para que se realice la inserción es que tiene que
// haber un único usuario cuyo primer apellido sea 'Cabeza'
if(rs.getInt("cuenta")==1) {
pst = conn_.prepareStatement(query2);
File file = new File(filename);
FileInputStream fis = new FileInputStream(file);
pst.setBinaryStream(1, fis, (int)file.length());
int result = pst.executeUpdate();
if(result != 0) success = true;
}
if(success) {
System.out.println("[INFO] Imagen añadida correctamente");
}else {
System.err.println("[ERROR] Imagen no añadida");
System.err.println("Si no ha saltado una excepción, los posibles fallos son:");
System.err.println("--> Imagen ya insertada en usuario");
System.err.println("--> No existe un usuario con apellido 'Cabeza'");
System.err.println("--> Existe más de un usuario apellidado 'Cabeza'");
}
}catch (SQLException _e) {
System.err.println("[EXCEPTION] Problemas con las Statement");
}catch (FileNotFoundException _e) {
System.err.println("[EXCEPTION] Fallo al abrir el archivo");
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage());
} finally {
try {
// Cerramos lo necesario
if(pst != null) pst.close();
if(st != null) st.close();
if(rs != null) rs.close();
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar algún elemento");
}
}
return success;
}else { // Si la conexión está cerrada
System.err.println("[ERROR] No hay conexion abierta");
return false;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////FUNCIONES PRIVADAS///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
//////////////////////////CHECK IF TABLE EXISTS//////////////////////////
/////////////////////////////////////////////////////////////////////////
// Función para comprobación de la existencia de una tabla en la base de datos
// Devuelve true si la tabla existe y false si no existe o salta alguna excepción
private boolean checkIfTableExists(String _table) {
DatabaseMetaData db = null;
ResultSet rs = null;
boolean exist = false;
try {
db = conn_.getMetaData(); // Cogemos el MetaData
rs = db.getTables(null, null, _table, new String[] {"TABLE"}); // Buscamos la tabla por su nombre
exist = rs.next(); // Si existe se almacena en rs
} catch (SQLException e) {
System.err.println("[EXCEPTION]Error al buscar la tabla " + _table);
} catch(Exception _e) {
System.err.println("[EXCEPTION]Error inesperado " + _e.getMessage());
}finally {
try {
//db no se tiene que cerrar.
if(rs!=null) rs.close(); //Cerramos rs.
}catch(SQLException _e) {
System.err.println("[EXCEPTION]Error al cerrar ResultSet");
}
}
return exist;
}
/////////////////////////////////////////////////////////////////////////
///////////////////////////HANDLE TABLE CREATION/////////////////////////
/////////////////////////////////////////////////////////////////////////
// Función de creación de tablas. Tiene de entradas la query en formato string
// de la creación de la tabla y otro string con el nombre de la tabla.
private boolean handleTableCreation(String _query, String _tableName) {
openConnection(); // Comprobamos la conexión a la base de datos
if(conn_ != null) { // Comprobamos que la conexión esté abierta
if(!checkIfTableExists(_tableName)) { // Si la tabla no existe
// Ejecutamos la query de creación de tabla
Statement st = null;
try {
st = conn_.createStatement();
st.executeUpdate(_query);
System.out.println("[INFO] Peticion de creacion de tabla " + _tableName + " realizada");
}catch (SQLException _e) {
System.err.println("[EXCEPTION]Error al crear tabla " + _tableName);
} catch(Exception _e) {
System.err.println("[EXCEPTION]Error inesperado " + _e.getMessage());
}finally {
try {
if(st!=null) st.close();
}catch(SQLException _e){
System.err.println("[EXCEPTION]Error al cerrar Statement");
}
}
if(checkIfTableExists(_tableName)) { // Comprobamos de nuevo para ver si se ha realizado con existo
System.out.println("[INFO] Tabla " + _tableName + " creada");
return true;
} else{
System.err.println("[ERROR] La tabla " + _tableName + " no se ha creado");
return false;
}
}else{ // Si la tabla existe
System.out.println("[WARNING] Tabla " + _tableName + " ya existe");
return false;
}
}else { // Si la conexión no existe
System.err.println("[ERROR] No hay conexion abierta");
return false;
}
}
/////////////////////////////////////////////////////////////////////////
/////////////////////////////STRING TO DATE//////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Función para gestionar distintos tipos de formatos de fecha
// a partir de un string. Esta función permite el soporte de 10 tipos de formatos.
// Le entrará un string que debería contener una fecha.
// Devuelve la fecha en formato java.sql.Date si está entre los 10 posibles
// formatos o null si el formato es otro o no es una fecha.
private java.sql.Date stringToDate(String _string){
// En primer lugar eliminamos cualquier tipo de separador que se
// encuentre en el string y lo sustituimos por un espacio.
String sDate = _string.replace("/", " ");
sDate = sDate.replace("-", " ");
sDate = sDate.replace(".", " ");
sDate = sDate.replace("_", " ");
// Ponemos los 3 elementos de la fecha en un vector
String[] vDate = sDate.split(" ");
// Format almacena el formato de fecha al que se parseará el string
SimpleDateFormat format = null;
// Si el primer elemento tiene 4 caractéres, ese será el año
if(vDate[0].length() == 4) {
format = new SimpleDateFormat("yyyy MM dd");
// Si el último elemento tiene 4 caractéres, ese será el año
}else if(vDate[2].length() == 4) {
format = new SimpleDateFormat("dd MM yyyy");
// Sino no se encuentra el año en esta fecha
}else {
System.err.println("[ERROR] Formato de fecha invalido");
return null;
}
Date parsedDate = null;
try {
// Usando el formato escogido se parse el string a java.util.Date
parsedDate = format.parse(sDate);
} catch (ParseException e) {
System.err.println("[EXCEPTION] Formato de fecha invalido");
return null;
}
// Parseo de java.ultil.Date a java.sql.Date
java.sql.Date sqlDate = new java.sql.Date(parsedDate.getTime());
return sqlDate;
}
/////////////////////////////////////////////////////////////////////////
///////////////////////////LOAD DATA TO TABLE////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Función que se encarga de la gestión de la inserción de los datos en una tabla.
// Devuelve la cantidad de elementos insertados.
private int loadDataToTable(String _fileName, String _table) {
int rowInserted = 0;
openConnection(); // Comprobamos que la conexión esté abierta
if(conn_ != null) { // Si está abierta
BufferedReader csvReader = null;
PreparedStatement pst = null;
try {
csvReader = new BufferedReader(new FileReader(_fileName)); // Abrimos el archivo csv
// Leemos la primera línea del csv donde se encuentran los nombres de las columnas.
String row = csvReader.readLine();
String tableElements = row.replace(";", ", ");
// Añadimos tantos interrogantes a la PreparedStatement como
// columnas tenga la tabla
int count = row.split(";").length;
String qms = "";
for(int i = 0; i < count; i++) {
qms += "?";
if(i != count-1) qms += ",";
}
// Preparamos el string de la query
String query = "INSERT INTO " + _table + "(" +
tableElements + ") " +
"VALUES(" + qms + ");";
conn_.setAutoCommit(false); // Autocommit false para evitar inserciones en caso de error
pst = conn_.prepareStatement(query); // Preparamos la statement
boolean wrongDate = false;
while ((row = csvReader.readLine()) != null) { // Leemos línea a línea el csv
String[] data = row.split(";");
// Esta parte es menos dinámica porque para poder usar la preparedStatement
// debemos conocer la forma de la tabla y los tipos.
// Es por ello que el else final dice que si queremos meter otra tabla con este método
// debemos programarlo.
if(_table == "capitulo") {
pst.setInt(1, Integer.parseInt(data[0]));
pst.setInt(2, Integer.parseInt(data[1]));
pst.setInt(3, Integer.parseInt(data[2]));
// Comprobamos que la fecha tiene formato soportado
java.sql.Date sqlDate = stringToDate(data[3]);
if(sqlDate != null) {
pst.setDate(4, sqlDate);
}else {
wrongDate = true;
break;
}
pst.setString(5, data[4]);
pst.setInt(6, Integer.parseInt(data[5]));
}else if (_table == "valora") {
pst.setInt(1, Integer.parseInt(data[0]));
pst.setInt(2, Integer.parseInt(data[1]));
pst.setInt(3, Integer.parseInt(data[2]));
pst.setInt(4, Integer.parseInt(data[3]));
// Comprobamos que la fecha tiene formato soportado
java.sql.Date sqlDate = stringToDate(data[4]);
if(sqlDate != null) {
pst.setDate(5, sqlDate);
}else {
wrongDate = true;
break;
}
pst.setInt(6, Integer.parseInt(data[5]));
}else {
System.err.println("[ERROR] Solo se pueden insertar datos a las tablas capitulo o valora");
System.err.println("Si se desean insertar datos a otras tablas, añadir otro else if");
break;
}
pst.executeUpdate(); // En cada iteración ejecutamos la query con los nuevos datos
rowInserted++; // Contamos una fila en cada iteración
}
// Comprobamos si la salida del bucle while es debido a un formato de fecha invalido
if(!wrongDate) { // Si ha ido todo bien
conn_.commit(); // Podemos hacer commit
}else { // Si el formato de fecha no está soportado
System.err.println("[ERROR] Rollback debido a fallo con el formato de fechas");
conn_.rollback();
rowInserted = 0;
}
} catch (FileNotFoundException _e) {
// No hacemos rollback ya que es anterior a la statement
System.err.println("[EXCEPTION] El archivo no existe");
}catch (IOException _e) {
// No hacemos rollback ya que es anterior a la statement
System.err.println("[EXCEPTION] Fallo en la apertura del csv");
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo con los PreparedStatement o haciendo Commit. Hacemos Rollback");
System.err.println("Posibles fallos:");
System.err.println("-> Tabla " + _table + " no creada");
System.err.println("-> Alguno de los datos ha sido previamente insertado");
try {
conn_.rollback(); // Rollback porque ha habido algún error
rowInserted = 0;
} catch (SQLException e) {
System.err.println("[EXCEPTION] Fallo haciendo rollback");
}
} catch(Exception _e) {
System.err.println("[EXCEPTION] Error inesperado: " + _e.getMessage() + ". Hacemos Rollback");
try {
conn_.rollback(); // Rollback para evitar problemas
rowInserted = 0;
} catch (SQLException e) {
System.err.println("[EXCEPTION] Fallo haciendo rollback");
}
} finally {
try {
// Cerramos los distintos elementos de la función
if(csvReader !=null) csvReader.close();
if(pst != null) pst.close();
conn_.setAutoCommit(true); // Ponemos la config original (default) al autocommit
} catch (IOException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el archivo");
} catch (SQLException _e) {
System.err.println("[EXCEPTION] Fallo al cerrar el Statement");
}
}
}else {
System.err.println("[ERROR] No hay conexion abierta");
}
return rowInserted * 6; // Como tenemos 6 columnas en ambas tablas multiplicamos el número de inserciones por 6
}
}
|
public class EducationalA {
private String degreeType;
private String major;
private String university;
private int graduationYear;
public EducationalA (String degreeType, String major, String university, int graduationYear) {
this.degreeType = degreeType;
this.major = major;
this.university = university;
this.graduationYear = graduationYear;
}
public String getDegreeType() {
return degreeType;
}
public void setDegreeType(String degreeType) {
this.degreeType = degreeType;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String getUniversity() {
return university;
}
public void setUniversity(String university) {
this.university = university;
}
public int getGraduationYear() {
return graduationYear;
}
public void setGraduationYear(int graduationYear) {
this.graduationYear = graduationYear;
}
@Override
public String toString() {
return "EducationalA{" +
"degreeType='" + degreeType + '\'' +
", major='" + major + '\'' +
", university='" + university + '\'' +
", graduationYear=" + graduationYear +
'}';
}
}
|
import textio.TextIO;
public class HowManyEggs {
public static void main (String [] args) {
int inputEggs;
int grossEggs;
int dozenEggs;
int remainderEggs;
int grossRemainder;
System.out.println("How many eggs do you have?");
inputEggs = TextIO.getInt();
grossEggs = inputEggs / 144;
grossRemainder = inputEggs % 144;
dozenEggs = grossRemainder / 12;
remainderEggs = grossRemainder % 12;
System.out.println("Your number of eggs is " + grossEggs + " gross, " + dozenEggs + " dozen, and " + remainderEggs);
}
}
|
package de.jmda.app.uml.settings.mdl.pckg.tree;
import java.util.Collection;
import de.jmda.core.util.PackageProvider;
abstract public class PackageTreeFactory
{
public static Tree createFromClassPathAndLoader()
{
Tree result = new Tree();
Collection<Package> packages = PackageProvider.instance().getPackagesByName().values();
packages.forEach(p -> result.insert(p));
return result;
}
static Tree create()
{
return new Tree();
}
}
|
package pub.iseekframework.utils.date;
import org.apache.commons.lang3.time.DateFormatUtils;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
/**
* desc： 常用的时间处理类 <br>
* author： wangsong <br>
* date： 2018/5/14 下午5:26 <br>
* version： v1.0.0 <br>
*/
public class DateUtils {
/**
* 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String formatDate(Date date, Object... pattern) {
String formatDate = null;
if (pattern != null && pattern.length > 0) {
formatDate = DateFormatUtils.format(date, pattern[0].toString());
} else {
formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
}
return formatDate;
}
/**
* 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
*/
public static String formatDateTime(Date date) {
if (date == null) {
return "";
}
return formatDate(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* 得到当前时间字符串 格式（HH:mm:ss）
*/
public static String getTime() {
return formatDate(new Date(), "HH:mm:ss");
}
/**
* 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
*/
public static String getDateTime() {
return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
}
/**
* 获取LocalDateTime时间
* @param time 时间字符串
* @return
*/
public static LocalDateTime getLocalDateTime(String time) {
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
return LocalDateTime.parse(time,df);
}
}
|
public class RomanToInteger {
public int romanToInt(String s) {
int result = 0;
int len = s.length();
char ch;
for(int i = 0; i < len; i++) {
ch = s.charAt(i);
if (ch == 'M') {
result += 1000;
} else if(ch == 'D') {
result += 500;
} else if (ch == 'C') {
if (i+1 < len && (s.charAt(i+1) == 'D' || s.charAt(i+1) == 'M')) {
result -= 100;
} else {
result += 100;
}
} else if (ch == 'L') {
result += 50;
} else if (ch == 'X') {
if (i+1 < len && (s.charAt(i+1) == 'L' || s.charAt(i+1) == 'C')) {
result -= 10;
} else {
result += 10;
}
} else if (ch == 'V') {
result += 5;
} else if (ch == 'I') {
if (i+1 < len && (s.charAt(i+1) == 'V' || s.charAt(i+1) == 'X')) {
result -= 1;
} else {
result += 1;
}
}
}
return result;
}
public static void main(String args[]) {
RomanToInteger sol = new RomanToInteger();
String[] strs = {
"", "I", "III", "V", "IX", // 0 ~ 10
"X", "XII", "XXVI", "XLIII", "L", "XCVIII", // 10 ~ 100
"C", "CCXLVII", "DCCVII", "DCCCXC", // 100 ~ 1000
"M", "MMCCCL", "MMMCDLVIII", "MMMCMXCIX" // 1000 ~ 3999
};
int[] results = {
0, 1, 3, 5, 9, // 0 ~ 10
10, 12, 26, 43, 50, 98, // 10 ~ 100
100, 247, 707, 890, // 100 ~ 1000
1000, 2350, 3458, 3999 // 1000 ~ 3999
};
int count = results.length;
int failed = 0;
int result;
for (int i = 0; i < count; i++) {
result = sol.romanToInt(strs[i]);
if (result != results[i]) {
failed++;
System.out.println("Test: " + strs[i] + ", expect: " + results[i] + ", while returned: " + result);
}
}
System.out.println("Test " + count + " cases: " + (count-failed) + " success, " + failed + " failed.");
}
}
|
package com.igitras.codegen.common.next;
/**
* Represents a CG element (class, interface, method or constructor) which can own a type
* parameter list.
* <p>
* Created by mason on 1/4/15.
*/
public interface CgTypeParameterListOwner extends CgMember {
/**
* Checks if the element has any type parameters.
*
* @return true if the element has type parameters, false otherwise
*/
boolean hasTypeParameters();
/**
* Returns the type parameter list for the element.
*
* @return the type parameter list, or null if the element has no type parameters.
*/
CgTypeParameterList getTypeParameterList();
/**
* Returns the array of type parameters for the element.
*
* @return the array of type parameters, or an empty array if the element has no type parameters.
*/
CgTypeParameter[] getTypeParameters();
}
|
package com.lr.service;
import com.lr.mapper.adminMapper;
import com.lr.pojo.Admin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class adminService {
@Autowired
private adminMapper adminMapper;
public Admin login(String username, String password) {
return adminMapper.login(new Admin(null, username, password));
}
}
|
package de.codingchallenge;
import org.testcontainers.containers.GenericContainer;
abstract class ContainerBaseTest {
static final GenericContainer MONGO_CONTAINER;
static {
MONGO_CONTAINER = new GenericContainer("mongo:latest").withExposedPorts(27017);
MONGO_CONTAINER.start();
}
ContainerBaseTest() {
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.