hexsha
stringlengths 40
40
| size
int64 8
1.04M
| content
stringlengths 8
1.04M
| avg_line_length
float64 2.24
100
| max_line_length
int64 4
1k
| alphanum_fraction
float64 0.25
0.97
|
|---|---|---|---|---|---|
afff0f34093b335747941cd2e65a29f8675c9a55
| 1,641
|
/*
KeywordScreenWindow.java
Copyright (C) 2003 Gerardo Horvilleur Martinez
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
package org.jrman.parser.keywords;
import org.jrman.parser.Tokenizer;
public class KeywordScreenWindow extends FrameKeywordParser {
public void parse(Tokenizer st) throws Exception {
boolean array = false;
int token = st.nextToken();
// Check por array
if (token == TK_LBRACE)
array = true;
else
st.pushBack();
// Expect left
match(st, TK_NUMBER);
float left = (float) st.nval;
// Expect right
match(st, TK_NUMBER);
float right = (float) st.nval;
// Expect bottom
match(st, TK_NUMBER);
float bottom = (float) st.nval;
// Expect top
match(st, TK_NUMBER);
float top = (float) st.nval;
if (array)
match(st, TK_RBRACE);
parser.setScreenWindow(left, right, bottom, top);
}
}
| 31.557692
| 76
| 0.665448
|
7b3107f77a7a9bcaac41d1fef9248e96c5b8bf03
| 2,479
|
/*
* Copyright 2020 Red Hat, Inc. and/or its affiliates.
*
* 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.kie.workbench.common.dmn.webapp.kogito.common.client.tour.providers;
import java.util.Optional;
import elemental2.dom.ClientRect;
import elemental2.dom.DomGlobal;
import elemental2.dom.Element;
import elemental2.dom.HTMLDocument;
import org.appformer.kogito.bridge.client.guided.tour.GuidedTourCustomSelectorPositionProvider.PositionProviderFunction;
import org.appformer.kogito.bridge.client.guided.tour.service.api.Rect;
public class HTMLElementsPositionProviderFactory implements PositionProviderFactory {
public PositionProviderFunction createPositionProvider() {
return selector ->
Optional.ofNullable(document().querySelector(selector))
.map(this::makeRect)
.orElse(Rect.NONE());
}
private Rect makeRect(final Element element) {
final ClientRect clientRect = element.getBoundingClientRect();
final int bottom = (int) clientRect.bottom;
final int top = (int) clientRect.top;
final int left = (int) clientRect.left;
final int right = (int) clientRect.right;
final int height = (int) clientRect.height;
final int width = (int) clientRect.width;
return makeRect(bottom, top, left, right, height, width);
}
Rect makeRect(final int bottom,
final int top,
final int left,
final int right,
final int height,
final int width) {
final Rect rect = new Rect();
rect.setBottom(bottom);
rect.setHeight(height);
rect.setLeft(left);
rect.setRight(right);
rect.setTop(top);
rect.setWidth(width);
rect.setX(left);
rect.setY(top);
return rect;
}
HTMLDocument document() {
return DomGlobal.document;
}
}
| 33.958904
| 120
| 0.667205
|
6610261904bb570612230073efc4fdde4546c95a
| 747
|
package org.xpdojo.bank;
import org.junit.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.CoreMatchers.is;
import static org.xpdojo.bank.Account.accountWithZeroBalance;
public class DepositScenarios {
@Test
public void canDepositMoneyToAnAccount() {
var account = accountWithZeroBalance();
account.deposit(Money.valueOf(10));
assertThat(account.balance(), is(Money.valueOf(10)));
}
@Test
public void canDepositMoneyToAnAccountAndBalanceAccumalates() {
var account = accountWithZeroBalance();
account.deposit(Money.valueOf(10));
account.deposit(Money.valueOf(20));
assertThat(account.balance(), is(Money.valueOf(30)));
}
}
| 26.678571
| 67
| 0.710843
|
81e6b306778ba873a9a12febaeb15a9d67d55acb
| 1,480
|
package com.showka.service.persistence.u07;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.showka.domain.builder.SeikyuBuilder;
import com.showka.domain.u01.Kokyaku;
import com.showka.domain.u01.NyukinKakeInfo;
import com.showka.domain.u07.Seikyu;
import com.showka.kubun.NyukinHohoKubun;
import com.showka.service.crud.u07.i.SeikyuCrud;
import com.showka.service.persistence.u07.i.SeikyuPersistence;
import com.showka.service.specification.u07.i.SeikyuSpecification;
import com.showka.system.exception.validate.ValidateException;
@Service
public class SeikyuPersistenceImpl implements SeikyuPersistence {
@Autowired
private SeikyuCrud seikyuCrud;
@Override
public void save(SeikyuSpecification spec) {
SeikyuBuilder b = new SeikyuBuilder();
// 顧客
Kokyaku kokyaku = spec.getKokyaku();
b.withKokyaku(kokyaku);
// 請求担当部署
b.withTantoBusho(kokyaku.getShukanBusho());
// 入金方法
Optional<NyukinKakeInfo> _nhk = kokyaku.getNyukinKakeInfo();
if (!_nhk.isPresent()) {
throw new ValidateException("請求対象の顧客に入金方法を設定してください。");
}
NyukinHohoKubun nyukinHohoKubun = _nhk.get().getNyukinHohoKubun();
b.withNyukinHohoKubun(nyukinHohoKubun);
// 請求日
b.withSeikyuDate(spec.getSeikyuDate());
// 支払日
b.withShiharaiDate(spec.getShiharaiDate());
// 明細
b.withSeikyuMeisai(spec.getSeikyuMeisai());
Seikyu seikyu = b.build();
seikyuCrud.save(seikyu);
}
}
| 30.204082
| 68
| 0.783784
|
06938835b8237d8087378cb8594a4cfd80cfff7f
| 2,868
|
package com.djk.order;
import com.djk.feign.cart.ShoppingCartService;
import com.djk.feign.goods.SpuService;
import com.djk.settlement.OrderSettlement;
import com.djk.settlement.OrderSettlementRequest;
import com.djk.settlement.SettlementService;
import com.djk.utils.Log;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* Created by dujinkai on 2018/7/26.
* 订单服务接口实现
*/
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
/**
* 注入结算服务接口
*/
@Autowired
private SettlementService settlementService;
/**
* 注入订单数据库接口
*/
@Autowired
private OrderMapper orderMapper;
/**
* 注入订单商品数据库接口
*/
@Autowired
private OrderSpuMapper orderSpuMapper;
/**
* 注入购物车远程服务接口
*/
@Autowired
private ShoppingCartService shoppingCartService;
/**
* 注入远程商品服务接口
*/
@Autowired
private SpuService spuService;
/**
* 分布式事务的考虑
* <p>
* 1。分布式事务比较难解决，尽量避免 这边可以避免，因为用的是同一个数据库所以可以使用本地事务，在订单模块可以直接操作减库存和删除购物车的操作 不调用商品服务和购物车服务提供的接口
* 2。这边是尽量研究下分布式事务 所以 减库存和删除购物车还是走服务提供的接口
* 思路 走强一致性 遇到服务之间的异常走补偿机制，如果遇到补偿超时 则走校验机制
*/
@Transactional
@Log
@Override
public int submitOrder(SubmitParams submitParams) {
if (Objects.isNull(submitParams) || !submitParams.validate()) {
log.error("submitOrder fail due to params is error...");
return -1;
}
// 获得订单的结算信息
OrderSettlement orderSettlement = settlementService.orderSettlement(OrderSettlementRequest.build(submitParams));
// 校验获取结算信息是否成功
if (Objects.isNull(orderSettlement) || !orderSettlement.isSuccess()) {
log.error("submitOrder error du to orderSettlement fail....");
return -1;
}
// 校验库存是否足够
// 获得订单信息
Order order = getOrder(orderSettlement, submitParams);
// 保存订单
orderMapper.saveOrder(order);
// 设置订单id
order.setOrderSpusOrderId();
// 保存订单下的商品信息
orderSpuMapper.saveOrderSpus(order.getOrderSpus());
// 删除购物车
shoppingCartService.deleteShoppingCart(submitParams.getIds());
// 扣减库存
spuService.reduceSpuStock(order.getOrderSpus().stream().map(OrderSpu::buildReduceSpu).collect(Collectors.toList()));
return 1;
}
/**
* 获得订单
*
* @param orderSettlement 订单结算信息
* @return 返回订单
*/
@Log
private Order getOrder(OrderSettlement orderSettlement, SubmitParams submitParams) {
return Order.build(orderSettlement, submitParams);
}
}
| 24.10084
| 124
| 0.670502
|
34043935e2f9f5368bd968d5a4e13c1fa6a89f89
| 1,999
|
/*
* Copyright 2020 Aleksandr Dorogush
*
* 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 com.adorogush.mirotask.model;
/** Immutable data class to hold the rate limit statistics for operation. */
public class RateLimitStat {
private final boolean isConsumed;
private final long rpm;
private final long available;
private final long nanosToWaitForRefill;
public RateLimitStat(
final boolean isConsumed,
final long rpm,
final long available,
final long nanosToWaitForRefill) {
this.isConsumed = isConsumed;
this.rpm = rpm;
this.available = available;
this.nanosToWaitForRefill = nanosToWaitForRefill;
}
/** {@code true} if operation happened and was not rate limited. */
public boolean isConsumed() {
return isConsumed;
}
/** Returns current value of Requests Per Minute configured. */
public long rpm() {
return rpm;
}
/** Returns the available remaining operations. */
public long available() {
return available;
}
/**
* Returns nanoseconds until the available remaining operations bucket will refill. {@code 0} if
* consumed successfully.
*/
public long nanosToWaitForRefill() {
return nanosToWaitForRefill;
}
@Override
public String toString() {
return "Probe{"
+ "isConsumed="
+ isConsumed
+ ", rpm="
+ rpm
+ ", available="
+ available
+ ", nanosToWaitForRefill="
+ nanosToWaitForRefill
+ '}';
}
}
| 27.013514
| 98
| 0.686843
|
c5c6eb6d0cbeafab65de836b2d9b9e8858c961a6
| 905
|
package com.spi;
import com.spi.demo.Animal;
import org.apache.dubbo.common.extension.ExtensionLoader;
import org.apache.dubbo.rpc.Protocol;
import java.util.Iterator;
import java.util.ServiceLoader;
public class MainClass {
public static void main(String[] args) {
// testServerLoader();
testProtocol();
}
private static void testServerLoader() {
ServiceLoader<Animal> animals = ServiceLoader.load(Animal.class);
Iterator<Animal> iterator = animals.iterator();
while (iterator.hasNext()) {
Animal animal = iterator.next();
animal.shout();
}
}
private static void testProtocol() {
ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol protocol = (Protocol) extensionLoader.getExtension("dubbo");
System.out.println(protocol);
}
}
| 22.073171
| 93
| 0.670718
|
3ef6522a05564709c18dbb5012b7d23a321b7c3c
| 3,187
|
package pl.javorex.resourceserver.config;
import ch.qos.logback.core.net.server.Client;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.client.registration.ClientRegistration;
import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
import org.springframework.security.oauth2.client.registration.InMemoryClientRegistrationRepository;
import org.springframework.security.oauth2.core.AuthorizationGrantType;
import org.springframework.security.oauth2.core.ClientAuthenticationMethod;
@Configuration
class Oauth2ClientsConfig {
private static final String SCOPE_OPENID = "openid";
@Bean
ClientRegistrationRepository clientRegistrationRepository() {
return new InMemoryClientRegistrationRepository(client1(), client2());
}
ClientRegistration client1() {
return ClientRegistration.withRegistrationId("client-1")
.issuerUri(Client1.issuerUri)
.clientId(Client1.clientId)
.clientSecret(Client1.clientSecret)
.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
.redirectUri(Client1.redirectUri)
.scope(SCOPE_OPENID)
.clientName(Client1.clientName)
.authorizationUri(Client1.authorizationUri)
.tokenUri(Client1.tokenUri)
.jwkSetUri(Client1.jwksSetUri)
.build();
}
ClientRegistration client2() {
return ClientRegistration.withRegistrationId("client-2")
.issuerUri(Client2.issuerUri)
.clientId(Client2.clientId)
.clientSecret(Client2.clientSecret)
.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
.redirectUri(Client2.redirectUri)
.scope(SCOPE_OPENID)
.clientName(Client2.clientName)
.authorizationUri(Client2.authorizationUri)
.tokenUri(Client2.tokenUri)
.jwkSetUri(Client2.jwksSetUri)
.build();
}
// /.well-known/oauth-authorization-server
// /.well-known/openid-configuration
private static class Client1 {
static String issuerUri = "http://localhost:9001";
static String clientId = "articles-client";
static String clientSecret = "secret";
static String clientName = "first";
static String redirectUri = "http://127.0.0.1:8080/login/oauth2/code/{registrationId}";
static String authorizationUri = issuerUri + "/oauth2/authorize";
static String tokenUri = issuerUri + "/oauth2/token";
static String jwksSetUri = issuerUri + "/oauth2/jwks";
}
private static class Client2 {
static String issuerUri = "http://localhost:9002";
static String clientId = "articles-client";
static String clientSecret = "secret";
static String clientName = "second";
static String redirectUri = "http://127.0.0.1:8080/login/oauth2/code/{registrationId}";
static String authorizationUri = issuerUri + "/oauth2/authorize";
static String tokenUri = issuerUri + "/oauth2/token";
static String jwksSetUri = issuerUri + "/oauth2/jwks";
}
}
| 41.38961
| 100
| 0.76059
|
f5f300c7b9d9c8ac02a6fb1905ffebe360255178
| 678
|
package com.CQJjFlowSu.dao;
import com.CQJjFlowSu.db.TUsers;
import com.CQJjFlowSu.db.TUsersExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface TUsersMapper {
int countByExample(TUsersExample example);
int deleteByExample(TUsersExample example);
int insert(TUsers record);
int insertSelective(TUsers record);
List<TUsers> selectByExample(TUsersExample example);
int updateByExampleSelective(@Param("record") TUsers record, @Param("example") TUsersExample example);
int updateByExample(@Param("record") TUsers record, @Param("example") TUsersExample example);
TUsers getUserByName(String username);
}
| 28.25
| 106
| 0.774336
|
90c527686bbfcc5ae08d4999bf4e9a53d0c241c5
| 1,045
|
package gulimall.seckill.to;
import gulimall.common.to.mq.SkuInfoTo;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* 商品的详细信息To
* @author 孙启新
* <br>FileName: SeckillSkuRedisTo
* <br>Date: 2020/08/17 10:54:23
*/
@Data
public class SeckillSkuRedisTo implements Serializable {
/**
* id
*/
private Long id;
/**
* 活动id
*/
private Long promotionId;
/**
* 活动场次id
*/
private Long promotionSessionId;
/**
* 商品id
*/
private Long skuId;
/**
* 秒杀价格
*/
private BigDecimal seckillPrice;
/**
* 秒杀总量
*/
private BigDecimal seckillCount;
/**
* 每人限购数量
*/
private BigDecimal seckillLimit;
/**
* 排序
*/
private Integer seckillSort;
/**
* 当前商品的开始时间
*/
private Long startTime;
/**
* 当前商品的结束时间
*/
private Long endTime;
/**
* 秒杀随机码
*/
private String randomCode;
/**
* 商品的详细信息
*/
private SkuInfoTo skuInfoTo;
}
| 15.367647
| 56
| 0.555024
|
34a3314a5cd159009c9e6e698a21d86423e697f3
| 1,653
|
package ru.konsort.la.service;
import org.junit.jupiter.api.Test;
import ru.konsort.la.service.Impl.HttpLocalServiceImpl;
/**
* Created by turov on 13.02.2017.
*/
class HttpLocalServiceImplTest {
HttpLocalServiceImpl httpLocalServiceImpl = new HttpLocalServiceImpl();
private String url = "http://46.146.200.251:8888";
@Test
public void send_get_karat_test() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/current_data.py?get_data=yes"));
}
@Test
public void send_get_sauter_read_day_test() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?read_day_sp_rk1=yes"));
}
@Test
public void send_get_sauter_read_night_test() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?read_night_sp_rk1=yes"));
}
@Test
public void send_get_sauter_read_coil_test() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?read_coil_57=yes"));
}
@Test
public void send_get_sauter_set_day_temp() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?day_setpoint_rk1=25.1"));
}
@Test
public void send_get_sauter_set_night_temp() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?night_setpoint_rk1=25.1"));
}
@Test
public void send_get_sauter_write_coil() throws Exception {
System.out.println(httpLocalServiceImpl.sendGet(url + "/cgi-bin/sauter.py?write_coil_57=0"));
}
}
| 34.4375
| 109
| 0.721113
|
8fb5ceff212582f0394221b645002bf110b1b775
| 2,536
|
package com.wotrd.dubbo.common.algorithm.sort;
/**
* 排序算法
*/
public class Souting {
/**
* 冒泡排序，每次便利都将相邻的两个数进行交换排序。知道全部拍完。
*/
public void bubbleSorting(){
int [] arr={1,4,2,5,3,8,7,9,6,10,11,7};
for (int i=0;i<arr.length-1;i++)
{
for (int j=0;j<arr.length-i-1;j++){
if (arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
showArr(arr);
}
/**
* 选择排序每次都是选择最小值放在最前面。
*/
public void selectSort(){
int [] arr={1,4,2,5,3,8,7,9,6,10,11,7};
for (int i=0;i<arr.length;i++){
for (int j=i+1;j<arr.length;j++){
if (arr[i]>arr[j]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
}
}
}
showArr(arr);
}
/**
* 插入排序，将一组数据分成两组，我分别将其称为有序组与待插入组。每次从待插入组中取出一个元素，
* 与有序组的元素进行比较，并找到合适的位置，将该元素插到有序组当中。就这样，每次插入一个元素，
* 有序组增加，待插入组减少。
*/
public void insertSorting(){
int [] arr={1,4,2,5,3,8,7,9,6,10,11,7};
for (int i=0;i<arr.length-1;i++){
int prio=arr[i+1];
int index=i;
while (index>0 && arr[index]>prio){
int temp = arr[index];
arr[index]= prio;
arr[index+1] = temp;
index --;
}
}
showArr(arr);
}
/**
* 希尔排序，比如现在有数组{82 ,31 ,29 ,71, 72, 42, 64, 5,110} 第一次取增量设置为array.length/2 = 4
* 然先从82开始以4为增量遍历直到末尾，得到（82,42） 排序得到{42 ,31 ,29 ,71, 72, 82, 64, 5,110}。
* 后从第二个数31开始重复上一个步骤，得到（31,64） 排序得到{42 ,31 ,29 ,71, 72, 82, 64, 5,110}...
* 以4为增量的遍历完数组之后，得到的结果是{42 ,31,5,71,72,82,64,29,110}
*/
public void shellSorting(){
int [] arr={82 ,31 ,29 ,71, 72, 42, 64, 5,110};
int increment= arr.length/2;
while (increment>=1){
for (int i=0;i<arr.length;i++){
for (int j=i;j<arr.length-increment;j=j+increment){
if (arr[j]>arr[j+increment]){
int temp = arr[j+increment];
arr[j+increment]=arr[j];
arr[j]=temp;
}
}
}
increment/=2;
}
showArr(arr);
}
private void showArr(int[] arr) {
for (int a:arr){
System.out.print(String.valueOf(a)+"-");
}
}
}
| 28.818182
| 82
| 0.429022
|
c40b03ad2ace943613e0d57a5bc1c52fcc1bfc62
| 4,218
|
package com.immfly.api.fights.handlers;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.immfly.external.service.ExternalFlightService;
import com.immfly.external.service.response.FlightInformationResponse;
import com.immfly.redis.RedisService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
@Component
public class GetFlightHandler {
private static final String EMPTY_RESPONSE = "{}";
private static final Logger logger = LogManager.getLogger(GetFlightHandler.class);
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private final Jedis jedis;
private final ExternalFlightService externalFlightService;
public GetFlightHandler(@Autowired RedisService redisService, @Autowired ExternalFlightService externalFlightService) {
this.jedis = redisService.getJedisInstance();
this.externalFlightService = externalFlightService;
}
public Object handleGetFlight(final String tailNumber, final String flightNumber) {
// We are getting the flight in Redis (Hash Type). <String, Map<String, String>>. Stored as <TailNumber, <FlightNumber, FlightInformation>>
String flightInformation = jedis.hget(tailNumber, flightNumber);
if (flightInformation == null) {
// Flight is not in Redis, we call the external service and try to store it in Redis Cache.
List<FlightInformationResponse> flightInformationResponseList = externalFlightService.getFlights(tailNumber);
if (flightInformationResponseList != null) {
saveFlightsToCache(tailNumber, flightInformationResponseList);
return getSpecificFlight(flightNumber, flightInformationResponseList);
} else {
// This Combination of TailNumber and FlightNumber does not exist.
logger.debug("No match found for: " + tailNumber + " " + flightNumber);
return EMPTY_RESPONSE;
}
}
return flightInformation;
}
/**
* Returns a Specific Flight as JSON
* @param flightNumber
* @param flightInformationResponseList
* @return Flight Information as JSON or EMPTY JSON if not found.
*/
private String getSpecificFlight(String flightNumber, List<FlightInformationResponse> flightInformationResponseList) {
final List<FlightInformationResponse> flightToReturn = flightInformationResponseList
.stream()
.filter(flightInfo -> flightNumber.equals(flightInfo.getFlightnumber()))
.limit(1)
.collect(Collectors.toList());
if (flightToReturn.size() == 1) {
try {
return OBJECT_MAPPER.writeValueAsString(flightToReturn.get(0));
} catch (JsonProcessingException e) {
logger.error("Error when parsing Flight", e);
}
}
return EMPTY_RESPONSE;
}
private void saveFlightsToCache(final String tailNumber, final List<FlightInformationResponse> flightInformationResponseList) {
AtomicBoolean error = new AtomicBoolean(false);
// We have to transform the List of FLights to a Map<String, String> for Redis Cache.
Map<String, String> flightInformationMap = flightInformationResponseList.stream().collect(Collectors.toMap(FlightInformationResponse::getFlightnumber, flightInfo -> {
try {
return OBJECT_MAPPER.writeValueAsString(flightInfo);
} catch (JsonProcessingException e) {
logger.error("Error when parsing FlightInformation", e);
error.set(true);
return "{}";
}
}));
// If no error when parsing we update the Redis Cache
if (!error.get()) {
jedis.hmset(tailNumber, flightInformationMap);
}
}
}
| 45.354839
| 174
| 0.694879
|
4d9c63ca108e96788d7b18836ee257e586a28ba5
| 4,462
|
package com.xc.common.exception;
import com.xc.common.api.ResponseVO;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import javax.validation.ConstraintViolationException;
import java.lang.reflect.Method;
/**
* 切面切在controller上捕获全局异常并处理
*
* @author Administrator
*/
@Component
@Aspect
@Slf4j
public class InterfaceRequestErrorAndPerformanceLog {
/**
* 切入到controller层的包和所有子包里的任意类的任意方法的执行
*/
@Pointcut("execution(* com.xc.*.controller..*.*(..))")
public void pointCut() {
}
@Around("pointCut()")
public Object handleControllerMethod(ProceedingJoinPoint pjp) throws Throwable {
long startTm = System.currentTimeMillis();
Object res;
try {
//处理入参特殊字符和sql注入攻击
checkRequestParam(pjp);
//Signature s = pjp.getSignature();
//执行访问接口操作
res = pjp.proceed(pjp.getArgs());
Long consumeTime = System.currentTimeMillis() - startTm;
log.info("耗时：" + consumeTime + "(毫秒).");
//当接口请求时间大于3秒时，标记为异常调用时间，并记录入库
if (consumeTime > 3000) {
log.warn("{" + pjp.getSignature() + "的执行时间超过三秒" + "}");
}
} catch (Exception throwable) {
res = handlerException(pjp, throwable);
}
return res;
}
/**
* 处理接口调用异常
*
* @param pjp
* @param e
* @return
*/
private ResponseVO handlerException(ProceedingJoinPoint pjp, Throwable e) {
//获取方法签名
Signature signature = pjp.getSignature();
//获取目标类
Object controller = pjp.getTarget();
//获取入参数
Object[] args = pjp.getArgs();
Class<?>[] parameterTypes = new Class<?>[args.length];
try {
for (int j = 0; j < args.length; j++) {
Object arg = args[j];
parameterTypes[j] = arg.getClass();
}
Method method = controller.getClass().getDeclaredMethod(signature.getName(), parameterTypes);
Class<?> returnType = method.getReturnType();
if (!returnType.equals(ResponseVO.class)) {
return null;
}
} catch (Exception ex) {
//TODO:出现空指针可能是get入参有问题
log.error(ex.getMessage());
}
ResponseVO apiResponse;
if (e.getClass().isAssignableFrom(ServiceException.class)) {
apiResponse = ResponseVO.errorInstance(e.getMessage());
} else if (e instanceof ConstraintViolationException) {
//利用校验框架的验证异常
String s = e.getMessage();
String msg = s.substring(s.indexOf(":") + 1);
apiResponse = ResponseVO.errorInstance(msg);
} else if (e instanceof RuntimeException) {
log.error("RuntimeException{方法：" + pjp.getSignature() + "， 参数：" + pjp.getArgs() + ",异常：" + e.getMessage() + "}", e);
apiResponse = ResponseVO.errorInstance(e.getMessage());
} else {
log.error("异常{方法：" + pjp.getSignature() + "， 参数：" + pjp.getArgs() + ",异常：" + e.getMessage() + "}", e);
apiResponse = ResponseVO.errorInstance(e.getMessage());
}
return apiResponse;
}
/**
* @Author: wzd
* @Description: 处理入参特殊字符和sql注入攻击
*/
private void checkRequestParam(ProceedingJoinPoint pjp) {
String str = String.valueOf(pjp.getArgs());
/* if (!IllegalStrFilterUtil.sqlStrFilter(str)) {
logger.info("访问接口：" + pjp.getSignature() + "，输入参数存在SQL注入风险！参数为：" + Lists.newArrayList(pjp.getArgs()).toString());
DcErrorEntity dcErrorEntity = interfaceErrorService.processDcErrorEntity(pjp.getSignature() + "",Lists.newArrayList(pjp.getArgs()).toString(),"输入参数存在SQL注入风险!");
throw new DataCenterException(dcErrorEntity);
}
if (!IllegalStrFilterUtil.isIllegalStr(str)) {
logger.info("访问接口：" + pjp.getSignature() + ",输入参数含有非法字符!，参数为：" + Lists.newArrayList(pjp.getArgs()).toString());
DcErrorEntity dcErrorEntity = interfaceErrorService.processDcErrorEntity(pjp.getSignature() + "",Lists.newArrayList(pjp.getArgs()).toString(),"输入参数含有非法字符!");
throw new DataCenterException(dcErrorEntity);
}*/
}
}
| 37.495798
| 172
| 0.606903
|
01d8185737bca16036207eb828416a6c0949e967
| 386
|
package com.idiotalex;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class AppTest {
protected static Logger logger = LoggerFactory.getLogger(AppTest.class);
}
| 24.125
| 76
| 0.818653
|
44bef5d86de8abb0799e444c1676967a8ff470d0
| 962
|
package org.lengyan.crawler.store.model.po.apipo.bsbdj;
public class BsbdjUserResult {
String pageToken;
String retcode;
String hasNext;
String appCode;
String dataType;
BsbdjUser[] data;
public String getPageToken() {
return pageToken;
}
public void setPageToken(String pageToken) {
this.pageToken = pageToken;
}
public String getRetcode() {
return retcode;
}
public void setRetcode(String retcode) {
this.retcode = retcode;
}
public String getHasNext() {
return hasNext;
}
public void setHasNext(String hasNext) {
this.hasNext = hasNext;
}
public String getAppCode() {
return appCode;
}
public void setAppCode(String appCode) {
this.appCode = appCode;
}
public String getDataType() {
return dataType;
}
public void setDataType(String dataType) {
this.dataType = dataType;
}
public BsbdjUser[] getData() {
return data;
}
public void setData(BsbdjUser[] data) {
this.data = data;
}
}
| 16.586207
| 55
| 0.701663
|
14da3062f190006d3da35405f6f401cbaa7b5588
| 321
|
package de.unistuttgart.vis.vita.services.entity;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
/**
* Test suite for tests concerning PlotViewService.
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({PlotViewServiceTest.class, PlotViewDuringAnalysisTest.class})
public class PlotViewServiceTests {
}
| 22.928571
| 82
| 0.800623
|
6174be4a52aaadf343bd3adad721c7c4e425e1e0
| 4,882
|
package com.jukusoft.rpgcreator.editor.javafx.controller;
import com.jukusoft.rpgcreator.editor.javafx.CreateProjectProgressDialog;
import com.jukusoft.rpgcreator.engine.javafx.FXMLController;
import com.jukusoft.rpgcreator.engine.utils.FileUtils;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.TextField;
import javafx.scene.input.KeyEvent;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Border;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
import java.io.File;
import java.net.URL;
import java.util.ResourceBundle;
/**
* Created by Justin on 30.05.2017.
*/
public class CreateProjectDialogController implements FXMLController, Initializable {
protected int DEFAULT_PORT = 1234;
protected final String CSS_FAILED_STYLE = "-fx-border-color:#ff0000; -fx-background-color:#c4cfed; ";
protected final String CSS_SUCCESS_STYLE = "-fx-border-color:#1b52f1; -fx-background-color:#c4cfed; ";
@FXML
protected TextField projectTitleTextField;
@FXML
protected TextField projectPathTextField;
@FXML
protected TextField serverIPTextField;
@FXML
protected TextField serverPortTextField;
@FXML
protected CheckBox includeAssetsCheckBox;
@FXML
protected Button createGameButton;
@FXML
protected Button choosePathButton;
protected Stage stage = null;
@Override
public void init(Stage stage, Scene scene, Pane pane) {
this.stage = stage;
projectPathTextField.setText(getBasePath());
//disable resize window
stage.setResizable(false);
createGameButton.setOnAction((ActionEvent event) -> {
//check, if form is valide
if (validate()) {
//create project
try {
create();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
});
projectTitleTextField.setOnKeyTyped((KeyEvent event) -> {
generateAndSetProjectPath();
validate();
});
projectPathTextField.setOnMouseMoved((MouseEvent event) -> {
generateAndSetProjectPath();
});
serverPortTextField.setText(DEFAULT_PORT + "");
this.choosePathButton.setOnAction((ActionEvent event) -> {
System.out.println("not supported yet.");
});
}
@Override
public void initialize(URL location, ResourceBundle resources) {
//
}
protected String getBasePath () {
return new File("./games/").getAbsolutePath().replace(".\\", "").replace("\\", "/");
}
/**
* check, if all form fields are valide
*
* @return true, if all fields are valide
*/
protected boolean validate () {
//TODO: add code here
//get project title
String title = projectTitleTextField.getText();
if (!title.equals(title.replace(" ", ""))) {
projectTitleTextField.setStyle(CSS_FAILED_STYLE);
return false;
} else {
projectTitleTextField.setStyle(CSS_SUCCESS_STYLE);
}
return true;
}
/**
* create new project
*/
protected void create () throws Exception {
//get title
String title = projectTitleTextField.getText();
//get path
String path = projectPathTextField.getText();
String ip = serverIPTextField.getText();
int port = Integer.parseInt(serverPortTextField.getText());
boolean includeAssets = this.includeAssetsCheckBox.isSelected();
//check, if directory already exists
if (new File(path).exists()) {
//check, if directory is empty
if (FileUtils.isDirEmpty(new File(path))) {
//delete directory
new File(path).delete();
} else {
//path already exists
this.projectPathTextField.setStyle(CSS_FAILED_STYLE);
return;
}
}
stage.hide();
//close window
stage.close();
System.out.println("open create project progress window.");
CreateProjectProgressDialog dialog = new CreateProjectProgressDialog(title, path, ip, port, includeAssets);
}
protected void generateAndSetProjectPath() {
String text = getBasePath() + "/" + projectTitleTextField.getText();
if (!projectPathTextField.getText().equals(text)) {
projectPathTextField.setText(getBasePath() + "/" + projectTitleTextField.getText());
}
}
@Override
public void run() {
//
}
}
| 27.426966
| 115
| 0.629045
|
f1b3c449362b9dd452466ae39e30eef256af8309
| 2,098
|
package org.bargains.offers;
import org.junit.Test;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.ZonedDateTime;
import static java.time.ZoneOffset.UTC;
import static org.assertj.core.api.Assertions.assertThat;
public class OfferTest {
@Test
public void isActive_whenNowUTCBetweenOfferValidity_returnsTrue() {
Instant futureDate = ZonedDateTime.now(UTC).plusDays(1).toInstant();
Offer nonExpiredOffer = Offer.builder()
.offerStarts(LocalDateTime.of(2017, Month.NOVEMBER, 1, 10, 10, 12).atZone(UTC).toInstant())
.offerEnds(futureDate)
.build();
assertThat(nonExpiredOffer.isActive()).isTrue();
}
@Test
public void isActive_whenNowUTCAfterOfferEnds_returnsFalse() {
Instant aSecondAgo = ZonedDateTime.now(UTC).minusSeconds(1).toInstant();
Offer nonExpiredOffer = Offer.builder()
.offerStarts(LocalDateTime.of(2017, Month.NOVEMBER, 1, 10, 10, 12).atZone(UTC).toInstant())
.offerEnds(aSecondAgo)
.build();
assertThat(nonExpiredOffer.isActive()).isFalse();
}
@Test
public void isActive_whenNowUTCBeforeOfferStarts_returnsFalse() {
Instant tomorrow = ZonedDateTime.now(UTC).plusDays(1).toInstant();
Offer nonExpiredOffer = Offer.builder()
.offerStarts(tomorrow)
.offerEnds(ZonedDateTime.now().plusYears(999).toInstant()) // We'll be well dead by then
.build();
assertThat(nonExpiredOffer.isActive()).isFalse();
}
@Test
public void isActive_whenOfferHasBeenCancelled_returnsFalse() {
Instant futureDate = ZonedDateTime.now(UTC).plusDays(1).toInstant();
Offer nonExpiredOffer = Offer.builder()
.offerStarts(LocalDateTime.of(2017, Month.NOVEMBER, 1, 10, 10, 12).atZone(UTC).toInstant())
.offerEnds(futureDate)
.cancelled(true)
.build();
assertThat(nonExpiredOffer.isActive()).isFalse();
}
}
| 35.559322
| 107
| 0.65348
|
7bf58699da9e8500fd0e5ae7dfacc18419eb9f04
| 1,019
|
package com.qunar.im.ui.view.zxing.manager;
import android.content.Intent;
import android.graphics.Bitmap;
/**
* 二维码策略类
* Created by HDL on 2017/6/28.
*/
abstract class IQRCodeStrategy {
/**
* 发起扫描
* @param requestCode
*/
abstract void scanning(int requestCode);
/**
* 结果回调
*
* @param requestCode 请求码
* @param resultCode 结果码
* @param data 数据
*/
abstract void onActivityResult(int requestCode, int resultCode, Intent data);
/**
* 创建二维码（不带logo）
*
* @param content 二维码的内容
* @param widthPix 二维码的宽
* @param heightPix 二维码的高
* @return
*/
abstract Bitmap createQRCode(String content, int widthPix, int heightPix);
/**
* 创建二维码（不带logo）
*
* @param content 二维码的内容
* @param widthPix 二维码的宽
* @param heightPix 二维码的高
* @param logoBm logo对应的bitmap对象
* @return
*/
abstract Bitmap createQRCode(String content, int widthPix, int heightPix, Bitmap logoBm);
}
| 21.229167
| 93
| 0.60844
|
fb77bbc90cf0f606e3424f55ae8caa4d30358bbf
| 2,077
|
package edu.virginia.vcgr.genii.client.jsdl;
import org.ggf.jsdl.FileSystemTypeEnumeration;
public class FilesystemFactory
{
static private Filesystem getScratchFilesystem(FileSystemTypeEnumeration type, String mountPoint, String mountSource) throws JSDLException
{
if (type != FileSystemTypeEnumeration.spool)
throw new InvalidJSDLException(String.format("%s filesytem must have a file system type of \"%s\".",
ScratchFilesystem.FILESYSTEM_NAME, ScratchFilesystem.FILESYSTEM_TYPE));
if (mountPoint != null)
throw new InvalidJSDLException(
String.format("%s filesystem cannot have a mount point element.", ScratchFilesystem.FILESYSTEM_NAME));
if (mountSource != null)
throw new InvalidJSDLException(
String.format("%s filesystem cannot have a mount source element.", ScratchFilesystem.FILESYSTEM_NAME));
return new ScratchFilesystem();
}
static private Filesystem getGridFilesystem(String name, FileSystemTypeEnumeration type, String mountPoint, String mountSource)
throws JSDLException
{
if (type != GridFilesystem.FILESYSTEM_TYPE)
throw new InvalidJSDLException(
String.format("Grid filesystem %s must have a file system type of \"%s\".", name, GridFilesystem.FILESYSTEM_TYPE));
if (mountPoint != null)
throw new InvalidJSDLException(String.format("Grid filesystem %s cannot have a mount point element.", name));
return new GridFilesystem(name, mountSource);
}
static public Filesystem getFilesystem(String name, FileSystemTypeEnumeration type, String mountPoint, String mountSource)
throws JSDLException
{
if (name == null)
throw new IllegalArgumentException("File systems cannot have a null name.");
if (name.equals(ScratchFilesystem.FILESYSTEM_NAME))
return getScratchFilesystem(type, mountPoint, mountSource);
if (mountSource != null) {
if (GridFilesystem.MOUNT_SOURCE_PATTERN.matcher(mountSource).matches())
return getGridFilesystem(name, type, mountPoint, mountSource);
}
throw new InvalidJSDLException(String.format("Don't know how to handle file system \"%s\".", name));
}
}
| 39.188679
| 139
| 0.773231
|
d8fdf68f8242a56416acabdc7867c6ad0f8b1a5e
| 1,382
|
package com.acg12.ui.adapter;
import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.ViewGroup;
import com.acg12.R;
import com.acg12.entity.CollectSubjectEntity;
import com.acg12.lib.ui.adapter.CommonRecyclerAdapter;
import com.acg12.ui.adapter.view.CollectSubjectViewHolder;
/**
* Created with Android Studio.
* User: mayn
* Date: 2019/2/28 17:34
* Description:
*/
public class CollectSubjectAdapter extends CommonRecyclerAdapter<CollectSubjectEntity> {
private CollectSubjectListener collectSubjectListener;
public CollectSubjectAdapter(Context mContext) {
super(mContext);
}
public void setCollectSubjectListener(CollectSubjectListener collectSubjectListener) {
this.collectSubjectListener = collectSubjectListener;
}
@Override
public RecyclerView.ViewHolder createView(ViewGroup parent, int viewType) {
return new CollectSubjectViewHolder(getItemView(R.layout.item_collect_subject, parent));
}
@Override
public void bindView(RecyclerView.ViewHolder holder, int position) {
((CollectSubjectViewHolder) holder).setCollectSubjectListener(collectSubjectListener);
((CollectSubjectViewHolder) holder).bindData(mContext, getList(), position);
}
public interface CollectSubjectListener {
void onClickCollect(int position);
}
}
| 30.711111
| 96
| 0.766281
|
d40f4e02bdd263209e25cb77e70256a03c243891
| 4,387
|
package com.banana.banana.main;
import android.content.Context;
import android.graphics.drawable.ColorDrawable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageView;
import android.widget.PopupWindow;
import android.widget.TextView;
import com.banana.banana.PropertyManager;
import com.banana.banana.R;
public class MainDialog extends PopupWindow{
Context mContext;
ImageView feelOneView, feelTwoView, feelThreeView, feelFourView, feelFiveView;
TextView feelFiveText;
public interface OnChangeFeelingListener{
public void OnFeelingClick(View view);
}
OnChangeFeelingListener changelistener;
public void setOnChangeFeelingListener(OnChangeFeelingListener listener) {
changelistener = listener;
}
public MainDialog(Context context) {
super(context);
mContext = context;
//setWidth(LayoutParams.WRAP_CONTENT);
//setHeight(LayoutParams.WRAP_CONTENT);
int width = context.getResources().getDimensionPixelSize(R.dimen.popup_feel_width);
int height = context.getResources().getDimensionPixelSize(R.dimen.popup_feel_height);
setWidth(width);
setHeight(height);
setOutsideTouchable(true);
setBackgroundDrawable(new ColorDrawable(android.graphics.Color.TRANSPARENT));
View view = LayoutInflater.from(context).inflate(R.layout.main_dialog, null);
setContentView(view);
feelOneView = (ImageView)view.findViewById(R.id.img_feel1);
feelTwoView = (ImageView)view.findViewById(R.id.img_feel2);
feelThreeView = (ImageView)view.findViewById(R.id.img_feel3);
feelFourView = (ImageView)view.findViewById(R.id.img_feel4);
feelFiveView = (ImageView)view.findViewById(R.id.img_feel5);
feelFiveText = (TextView)view.findViewById(R.id.text_feel5);
String gender = PropertyManager.getInstance().getUserGender();
if(gender.equals("M")) {
feelOneView.setImageResource(R.drawable.main_emotion_select_angry);
feelTwoView.setImageResource(R.drawable.main_emotion_select_sick);
feelThreeView.setImageResource(R.drawable.main_emotion_select_sexy);
feelFourView.setImageResource(R.drawable.main_emotion_select_happy);
feelFiveView.setImageResource(R.drawable.man_circle_basic);
feelFiveText.setText("진지진지");
} else if(gender.equals("F")) {
feelOneView.setImageResource(R.drawable.woman_circle_angry);
feelTwoView.setImageResource(R.drawable.woman_circle_sick);
feelThreeView.setImageResource(R.drawable.woman_circle_sexy);
feelFourView.setImageResource(R.drawable.woman_circle_happy);
feelFiveView.setImageResource(R.drawable.woman_circle_basic);
feelFiveText.setText("도도도도");
}
feelOneView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if(changelistener != null) {
changelistener.OnFeelingClick(v);
}
dismiss();
}
});
feelTwoView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if(changelistener != null) {
changelistener.OnFeelingClick(v);
}
dismiss();
}
});
feelThreeView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if(changelistener != null) {
changelistener.OnFeelingClick(v);
}
dismiss();
}
});
feelFourView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if(changelistener != null) {
changelistener.OnFeelingClick(v);
}
dismiss();
}
});
feelFiveView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if(changelistener != null) {
changelistener.OnFeelingClick(v);
}
dismiss();
}
});
}
/*
@Override
public void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setStyle(STYLE_NO_TITLE, 0);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// TODO Auto-generated method stub
View view = inflater.inflate(R.layout.main_dialog, container, false);
return view;
}*/
}
| 28.303226
| 87
| 0.739002
|
2d8000438302da9df497fd78767f2bdf53532664
| 815
|
package com.diagnosis_gateway.gateway.model;
import javax.persistence.Entity;
import javax.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Diabetes {
@Id
@GeneratedValue(strategy = IDENTITY)
private Integer id;
private String username;
private Integer pregnacies;
private Double Glucose; // yes
private Double BloodPressure;
private Double SkinThickness;
private Double Insulin; // yes
private Double BMI; // yes
private Double DiabetesPedigreeFunction;
private Double age;
private Integer outcome;
private Double probability;
}
| 23.970588
| 56
| 0.765644
|
bb86bf5a0e9773792a2a300fbc866e46dce59d56
| 1,437
|
package io.github.iamazy.elasticsearch.dsl.sql.parser.query.join;
import io.github.iamazy.elasticsearch.dsl.antlr4.ElasticsearchParser;
import io.github.iamazy.elasticsearch.dsl.sql.model.AtomicQuery;
import io.github.iamazy.elasticsearch.dsl.sql.parser.BoolExpressionParser;
import io.github.iamazy.elasticsearch.dsl.sql.parser.ExpressionQueryParser;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.join.query.JoinQueryBuilders;
/**
* @author iamazy
* @date 2019/8/2
**/
public class HasChildQueryParser implements ExpressionQueryParser<ElasticsearchParser.HasChildClauseContext> {
@Override
public AtomicQuery parse(ElasticsearchParser.HasChildClauseContext expression) {
String type = expression.type.getText();
BoolExpressionParser boolExpressionParser=new BoolExpressionParser();
QueryBuilder queryBuilder = boolExpressionParser.parseBoolQueryExpr(expression.query);
QueryBuilder hasChildQueryBuilder=JoinQueryBuilders.hasChildQuery(type,queryBuilder, ScoreMode.Avg);
AtomicQuery atomicQuery= new AtomicQuery(hasChildQueryBuilder);
atomicQuery.getHighlighter().addAll(boolExpressionParser.highlighter);
return atomicQuery;
}
@Override
public boolean isMatchExpressionInvocation(Class clazz) {
return ElasticsearchParser.HasChildClauseContext.class==clazz;
}
}
| 43.545455
| 110
| 0.798191
|
942f375e074bf320a77a43489906cf942dbc774e
| 2,231
|
/*
* Copyright 2022.1-2022
* StarWhale.ai All right reserved. This software is the confidential and proprietary information of
* StarWhale.ai ("Confidential Information"). You shall not disclose such Confidential Information and shall use it only
* in accordance with the terms of the license agreement you entered into with StarWhale.com.
*/
package ai.starwhale.mlops.agent.task.inferencetask;
import java.util.ArrayDeque;
import java.util.List;
import java.util.Queue;
import java.util.Vector;
public class TaskPool {
public final Queue<InferenceTask> preparingTasks = new ArrayDeque<>();
public final List<InferenceTask> runningTasks = new Vector<>();
public final List<InferenceTask> uploadingTasks = new Vector<>();
public final List<InferenceTask> finishedTasks = new Vector<>();
public final List<InferenceTask> archivedTasks = new Vector<>();
public final List<InferenceTask> canceledTasks = new Vector<>();
public final List<InferenceTask> errorTasks = new Vector<>();
public final List<Long> needToCancel = new Vector<>();
public void fill(InferenceTask task) {
switch (task.getStatus()) {
case CREATED:
break;
case PREPARING:
preparingTasks.add(task);
break;
case RUNNING:
runningTasks.add(task);
break;
case UPLOADING:
uploadingTasks.add(task);
break;
case FINISHED:
finishedTasks.add(task);
break;
case ARCHIVED:
archivedTasks.add(task);
break;
case EXIT_ERROR:
errorTasks.add(task);
break;
case CANCELED:
canceledTasks.add(task);
}
}
/**
* whether init successfully
*/
private volatile boolean ready = false;
public boolean isReady() {
return ready;
}
public void setToReady() {
ready = true;
}
}
| 33.80303
| 120
| 0.558942
|
30b0fe62ee986c4129620489a73ba27e037e826e
| 1,335
|
package org.apidb.eupathsitecommon.watar.pages;
import java.text.NumberFormat;
import java.text.ParseException;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class SearchResultsPage extends AjaxPage{
private By primaryKeyColumn = By.cssSelector(".HeadingCell--key-primary_key");
private By organismFilterFirstNode = By.cssSelector(".wdk-CheckboxTreeItem:nth-child(1) .OrganismFilter--NodeCount");
public SearchResultsPage(WebDriver driver, String url) {
super(driver, url);
}
@Override
public void waitForPageToLoad() {
new WebDriverWait(driver, 30, 3)
.until(
ExpectedConditions.presenceOfElementLocated(this.primaryKeyColumn)
);
}
public int organismFilterFirstNodeCount() {
new WebDriverWait(driver, 30, 3)
.until(
ExpectedConditions.presenceOfElementLocated(this.organismFilterFirstNode)
);
try {
return NumberFormat.getNumberInstance(java.util.Locale.US).parse(this.driver.findElement(this.organismFilterFirstNode).getText()).intValue();
// return Integer.parseInt(this.driver.findElement(this.organismFilterFirstNode).getText());
}
catch (ParseException e) {
}
return 0;
}
}
| 30.340909
| 147
| 0.747566
|
02e7b551a613d131966a5591f949ea505c3b03f1
| 10,670
|
/**
* Copyright 2018-2019 rideOS, Inc.
*
* 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 ai.rideos.android.interactors;
import static junit.framework.TestCase.assertEquals;
import static org.mockito.Matchers.any;
import ai.rideos.android.common.authentication.User;
import ai.rideos.android.common.model.LatLng;
import ai.rideos.android.common.model.TaskLocation;
import ai.rideos.android.common.reactive.SchedulerProviders.TrampolineSchedulerProvider;
import ai.rideos.android.common.utils.Locations;
import ai.rideos.android.model.ContactInfo;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.PickupDropoff;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.RiderInfo;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.Stop;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.TripDefinition;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.TripInfo;
import ai.rideos.api.commons.ride_hail_commons.RideHailCommons.VehicleFilter;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.DispatchParameters;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.GetActiveTripIdResponse;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.GetActiveTripIdResponse.ActiveTrip;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.GetActiveTripIdResponse.NoActiveTrip;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.RequestTripRequest;
import ai.rideos.api.ride_hail_rider.v1.RideHailRider.RequestTripResponse;
import ai.rideos.api.ride_hail_rider.v1.RideHailRiderServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.inprocess.InProcessChannelBuilder;
import io.grpc.inprocess.InProcessServerBuilder;
import io.grpc.stub.StreamObserver;
import io.grpc.testing.GrpcCleanupRule;
import io.reactivex.Single;
import io.reactivex.observers.TestObserver;
import java.io.IOException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
public class DefaultRiderTripInteractorTest {
private static final String API_TOKEN = "token";
private static final String PASSENGER_ID = "passenger-1";
private static final ContactInfo CONTACT_INFO = new ContactInfo("Passenger 1", "111-222-3333");
private static final String FLEET_ID = "fleet-1";
private static final String TRIP_ID = "task-1";
private static final LatLng ORIGIN = new LatLng(0, 0);
private static final LatLng DESTINATION = new LatLng(1, 1);
private static final String VEHICLE_ID = "vehicle-1";
@Rule
public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
private final RideHailRiderServiceGrpc.RideHailRiderServiceImplBase mockBase = Mockito.mock(
RideHailRiderServiceGrpc.RideHailRiderServiceImplBase.class
);
private DefaultRiderTripInteractor interactorUnderTest;
@SuppressWarnings("unchecked")
@Before
public void setUp() throws IOException {
String serverName = InProcessServerBuilder.generateName();
// Create a server, add service, start, and register for automatic graceful shutdown.
grpcCleanup.register(InProcessServerBuilder
.forName(serverName).directExecutor().addService(mockBase).build().start());
// Create a client channel and register for automatic graceful shutdown.
final ManagedChannel channel = grpcCleanup.register(
InProcessChannelBuilder.forName(serverName).directExecutor().build());
final User user = Mockito.mock(User.class);
Mockito.when(user.fetchUserToken()).thenReturn(Single.just(API_TOKEN));
Mockito.doAnswer(invocation -> {
final StreamObserver<RequestTripResponse> observer =
(StreamObserver<RequestTripResponse>) invocation.getArguments()[1];
observer.onNext(RequestTripResponse.getDefaultInstance());
observer.onCompleted();
return null;
}).when(mockBase).requestTrip(Mockito.any(), Mockito.any());
interactorUnderTest = new DefaultRiderTripInteractor(
() -> channel,
user,
() -> TRIP_ID,
new TrampolineSchedulerProvider()
);
}
@Test
public void testCanCreateTaskForPassenger() {
final RequestTripRequest expectedRequest = RequestTripRequest.newBuilder()
.setId(TRIP_ID)
.setFleetId(FLEET_ID)
.setRiderId(PASSENGER_ID)
.setDefinition(
TripDefinition.newBuilder()
.setPickupDropoff(
PickupDropoff.newBuilder()
.setPickup(Stop.newBuilder().setPosition(Locations.toRideOsPosition(ORIGIN)))
.setDropoff(Stop.newBuilder().setPosition(Locations.toRideOsPosition(DESTINATION)))
.setRiderCount(1)
)
)
.setInfo(
TripInfo.newBuilder().setRiderInfo(
RiderInfo.newBuilder().setContactInfo(
RideHailCommons.ContactInfo.newBuilder()
.setName(CONTACT_INFO.getName())
.setPhoneNumber(CONTACT_INFO.getPhoneNumber())
)
)
)
.setDispatchParameters(DispatchParameters.getDefaultInstance())
.build();
final TestObserver<String> testObserver = interactorUnderTest.createTripForPassenger(
PASSENGER_ID,
CONTACT_INFO,
FLEET_ID,
1,
new TaskLocation(ORIGIN),
new TaskLocation(DESTINATION)
).test();
final ArgumentCaptor<RequestTripRequest> callbackCaptor = ArgumentCaptor.forClass(RequestTripRequest.class);
Mockito.verify(mockBase).requestTrip(callbackCaptor.capture(), any());
final RequestTripRequest actualRequest = callbackCaptor.getValue();
assertEquals(expectedRequest, actualRequest);
}
@Test
public void testCanCreateTaskForPassengerAndVehicle() {
final RequestTripRequest expectedRequest = RequestTripRequest.newBuilder()
.setId(TRIP_ID)
.setFleetId(FLEET_ID)
.setRiderId(PASSENGER_ID)
.setDefinition(
TripDefinition.newBuilder()
.setPickupDropoff(
PickupDropoff.newBuilder()
.setPickup(Stop.newBuilder().setPosition(Locations.toRideOsPosition(ORIGIN)))
.setDropoff(Stop.newBuilder().setPosition(Locations.toRideOsPosition(DESTINATION)))
.setRiderCount(1)
)
)
.setInfo(
TripInfo.newBuilder().setRiderInfo(
RiderInfo.newBuilder().setContactInfo(
RideHailCommons.ContactInfo.newBuilder()
.setName(CONTACT_INFO.getName())
.setPhoneNumber(CONTACT_INFO.getPhoneNumber())
)
)
)
.setDispatchParameters(
DispatchParameters.newBuilder()
.addVehicleFilter(VehicleFilter.newBuilder().setVehicleId(VEHICLE_ID))
)
.build();
final TestObserver<String> testObserver = interactorUnderTest.createTripForPassengerAndVehicle(
PASSENGER_ID,
CONTACT_INFO,
VEHICLE_ID,
FLEET_ID,
1,
new TaskLocation(ORIGIN),
new TaskLocation(DESTINATION)
).test();
final ArgumentCaptor<RequestTripRequest> callbackCaptor = ArgumentCaptor.forClass(RequestTripRequest.class);
Mockito.verify(mockBase).requestTrip(callbackCaptor.capture(), any());
final RequestTripRequest actualRequest = callbackCaptor.getValue();
assertEquals(expectedRequest, actualRequest);
}
@Test
public void testGetCurrentTripForPassengerWhenTripIsActive() {
final GetActiveTripIdResponse tripResponse = GetActiveTripIdResponse.newBuilder()
.setActiveTrip(ActiveTrip.newBuilder().setId(TRIP_ID))
.build();
setActiveTripResponse(tripResponse);
interactorUnderTest.getCurrentTripForPassenger(PASSENGER_ID).test()
.assertValueCount(1)
.assertValueAt(0, maybeId -> maybeId.isPresent() && maybeId.get().equals(TRIP_ID));
}
@Test
public void testNoCurrentTripReturnedWhenNoTripsActive() {
final GetActiveTripIdResponse tripResponse = GetActiveTripIdResponse.newBuilder()
.setNoActiveTrip(NoActiveTrip.getDefaultInstance())
.build();
setActiveTripResponse(tripResponse);
interactorUnderTest.getCurrentTripForPassenger(PASSENGER_ID).test()
.assertValueCount(1)
.assertValueAt(0, maybeId -> !maybeId.isPresent());
}
@SuppressWarnings("unchecked")
@Test
public void testNoCurrentTripReturnedWhenCallFails() {
Mockito.doAnswer(invocation -> {
final StreamObserver<GetActiveTripIdResponse> observer =
(StreamObserver<GetActiveTripIdResponse>) invocation.getArguments()[1];
observer.onError(new IOException());
return null;
}).when(mockBase).getActiveTripId(Mockito.any(), Mockito.any());
interactorUnderTest.getCurrentTripForPassenger(PASSENGER_ID).test()
.assertValueCount(1)
.assertValueAt(0, maybeId -> !maybeId.isPresent());
}
@SuppressWarnings("unchecked")
private void setActiveTripResponse(final GetActiveTripIdResponse response) {
Mockito.doAnswer(invocation -> {
final StreamObserver<GetActiveTripIdResponse> observer =
(StreamObserver<GetActiveTripIdResponse>) invocation.getArguments()[1];
observer.onNext(response);
observer.onCompleted();
return null;
}).when(mockBase).getActiveTripId(Mockito.any(), Mockito.any());
}
}
| 43.55102
| 116
| 0.679194
|
a85608fdab9d30f3466fd29ba45d04ca8f5a129a
| 227
|
package com.stevekung.skyblockcatia.utils;
import net.minecraft.client.network.NetworkPlayerInfo;
public interface IViewerLoader
{
boolean isLoadedFromViewer();
NetworkPlayerInfo setLoadedFromViewer(boolean loaded);
}
| 25.222222
| 58
| 0.823789
|
c2a95b7f24c8176201f7d59873190b2cf58deb46
| 2,860
|
package eu.wauz.wauzcore.building.shapes;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Biome;
/**
* An abstract brush to paint block structures.
*
* @author Wauzmons
*/
public abstract class WauzBrush {
/**
* The id of the brush.
*/
private final String uuid;
/**
* The shape of the brush.
*/
private WauzShape shape;
/**
* The material of the brush.
*/
private Material material;
/**
* The biome of the brush.
*/
private Biome biome;
/**
* Creates a new instance of this brush.
*/
protected WauzBrush() {
this.uuid = UUID.randomUUID().toString();
}
/**
* @return The id of the brush.
*/
public final String getUuid() {
return uuid;
}
/**
* @return The item stack lore of the brush.
*/
public final List<String> getLore() {
List<String> info = new ArrayList<>();
info.add(ChatColor.WHITE + "Shape:" + ChatColor.LIGHT_PURPLE + " " + getName().toUpperCase());
if(material != null) {
info.add(ChatColor.WHITE + "Material:" + ChatColor.GREEN + " " + material);
}
if(biome != null) {
info.add(ChatColor.WHITE + "Biome:" + ChatColor.GREEN + " " + biome);
}
info.add(ChatColor.WHITE + "Radius:" + ChatColor.YELLOW + " " + shape.getRadius());
info.add(ChatColor.WHITE + "Height:" + ChatColor.YELLOW + " " + shape.getHeightString());
info.add("");
info.add(ChatColor.DARK_GRAY + "Brush UUID: " + uuid);
return info;
}
/**
* @return The name of the brush.
*/
public abstract String getName();
/**
* Gets a new instance of this brush.
*
* @param radius The radius of the brush.
* @param height The height of the brush.
*
* @return The created instance.
*/
public abstract WauzBrush getInstance(int radius, int height);
/**
* Sets the shape of the brush.
*
* @param shape The shape of the brush.
*
* @return The modified brush.
*/
protected final WauzBrush withShape(WauzShape shape) {
this.shape = shape;
return this;
}
/**
* Sets the material of the brush.
*
* @param material The material of the brush.
*
* @return The modified brush.
*/
public final WauzBrush withMaterial(Material material) {
this.material = material;
return this;
}
/**
* Sets the biome of the brush.
*
* @param biome The biome of the brush.
*
* @return The modified brush.
*/
public final WauzBrush withBiome(Biome biome) {
this.biome = biome;
return this;
}
/**
* Uses the brush at the given location.
*
* @param location The location to use the brush at.
*/
public void paint(Location location) {
if(material != null) {
shape.setMaterial(location, material);
}
if(biome != null) {
shape.setBiome(location, biome);
}
}
}
| 20.724638
| 96
| 0.640909
|
fb358f1acea90092d50da781638e8919ce1d3ac2
| 4,170
|
package com.b3tuning.b3console.view.config.trans;
import com.b3tuning.b3console.view.BaseView;
import com.b3tuning.b3console.view.config.CanBusConfigView;
import com.b3tuning.b3console.view.utils.buttonInputField.IntegerButtonInputField;
import de.saxsys.mvvmfx.InjectViewModel;
import de.saxsys.mvvmfx.utils.validation.visualization.ControlsFxVisualizer;
import javafx.fxml.FXML;
import javafx.scene.layout.AnchorPane;
import javafx.util.converter.DoubleStringConverter;
import javafx.util.converter.IntegerStringConverter;
import lombok.extern.slf4j.XSlf4j;
import org.controlsfx.validation.decoration.StyleClassValidationDecoration;
import javax.inject.Inject;
import static org.reactfx.EventStreams.nonNullValuesOf;
/*
* Created on: May 04, 2020
* Author: James Hildebrand
* of B3Tuning
* b3tuning@gmail.com
*
* Copyright (C) 2020 B3Tuning, LLC.
*/
@XSlf4j
public class TransConfigView extends BaseView<TransConfigViewModel> {
@FXML private IntegerButtonInputField encMax;
@FXML private IntegerButtonInputField encMin;
@FXML private IntegerButtonInputField maxCurrent;
@FXML private IntegerButtonInputField aggKp;
@FXML private IntegerButtonInputField aggKi;
@FXML private IntegerButtonInputField aggKd;
@FXML private IntegerButtonInputField consKp;
@FXML private IntegerButtonInputField consKi;
@FXML private IntegerButtonInputField consKd;
@SuppressWarnings("unused")
@FXML
private AnchorPane canBusConfig;
@SuppressWarnings("unused")
@FXML
private CanBusConfigView canBusConfigController;
private final ControlsFxVisualizer visualizer = new ControlsFxVisualizer();
@InjectViewModel private TransConfigViewModel viewModel;
@Inject
public TransConfigView() {
log.entry();
}
public void initialize() {
log.entry();
IntegerStringConverter intToString = new IntegerStringConverter();
DoubleStringConverter doubleToString = new DoubleStringConverter();
manage(nonNullValuesOf(viewModel.configProperty()).subscribe(c -> {
log.entry();
canBusConfigController.getViewModel().configProperty().set(c.getCanBus());
c.canBusProperty().bindBidirectional(canBusConfigController.getViewModel().configProperty());
encMax.textProperty().bindBidirectional(c.ems22AProperty().get().encMaxProperty(), intToString);
encMin.textProperty().bindBidirectional(c.ems22AProperty().get().encMinProperty(), intToString);
maxCurrent.textProperty().bindBidirectional(c.vnh5019Property().get().maxCurrentProperty(), intToString);
aggKp.textProperty().bindBidirectional(c.pidProperty().get().aggKpProperty(), doubleToString);
aggKi.textProperty().bindBidirectional(c.pidProperty().get().aggKiProperty(), doubleToString);
aggKd.textProperty().bindBidirectional(c.pidProperty().get().aggKdProperty(), doubleToString);
consKp.textProperty().bindBidirectional(c.pidProperty().get().consKpProperty(), doubleToString);
consKi.textProperty().bindBidirectional(c.pidProperty().get().consKiProperty(), doubleToString);
consKd.textProperty().bindBidirectional(c.pidProperty().get().consKdProperty(), doubleToString);
}));
initializeValidation();
}
private void initializeValidation() {
log.entry();
visualizer.setDecoration(new StyleClassValidationDecoration());
visualizer.initVisualization(viewModel.encMaxValidation(), encMax.getTextField(), true);
visualizer.initVisualization(viewModel.encMinValidation(), encMin.getTextField(), true);
visualizer.initVisualization(viewModel.currentMaxValidation(), maxCurrent.getTextField(), true);
visualizer.initVisualization(viewModel.aggKpValidation(), aggKp.getTextField(), true);
visualizer.initVisualization(viewModel.aggKiValidation(), aggKi.getTextField(), true);
visualizer.initVisualization(viewModel.aggKdValidation(), aggKd.getTextField(), true);
visualizer.initVisualization(viewModel.consKpValidation(), consKp.getTextField(), true);
visualizer.initVisualization(viewModel.consKiValidation(), consKi.getTextField(), true);
visualizer.initVisualization(viewModel.consKdValidation(), consKd.getTextField(), true);
}
@Override
public void dispose() {
log.entry();
super.dispose();
}
}
| 36.902655
| 108
| 0.791607
|
df359f42d0c22d52a7cbab80e868b9308c22f034
| 556
|
/*
* Created on Nov 10, 2006
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package biomight.chemistry.molecule.receptor;
/**
* @author SurferJim
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class NicotinicAcetylCholineReceptors {
// It consists of a pentamer of protein subunits,
// with two binding sites for acetylcholine
}
| 24.173913
| 73
| 0.714029
|
04c6f028646c41290744fca38565e7736ff33059
| 1,898
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.servicecomb.qps;
import org.apache.servicecomb.qps.strategy.AbstractQpsStrategy;
import org.apache.servicecomb.qps.strategy.FixedWindowStrategy;
import org.apache.servicecomb.qps.strategy.LeakyBucketStrategy;
import org.junit.Assert;
import org.junit.Test;
/**
* @Author GuoYl123
* @Date 2020/7/16
**/
public class TestQpsStrategy {
@Test
public void testFixedWindowStrategy() {
AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy();
qpsStrategy.setKey("abc");
qpsStrategy.setQpsLimit(100L);
Assert.assertEquals(false, qpsStrategy.isLimitNewRequest());
qpsStrategy.setQpsLimit(1L);
Assert.assertEquals(true, qpsStrategy.isLimitNewRequest());
}
@Test
public void testLeakyBucketStrategy() {
LeakyBucketStrategy qpsStrategy = new LeakyBucketStrategy();
qpsStrategy.setKey("abc");
qpsStrategy.setQpsLimit(100L);
Assert.assertEquals(false, qpsStrategy.isLimitNewRequest());
qpsStrategy.setQpsLimit(1L);
qpsStrategy.setBucketLimit(1L);
Assert.assertEquals(true, qpsStrategy.isLimitNewRequest());
}
}
| 33.298246
| 75
| 0.75922
|
53db9d56c6d3960a7d691f156112dbb14a38807e
| 1,388
|
package edu.wpi.first.embeddedtools.nativedeps;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.gradle.api.Project;
import org.gradle.nativeplatform.BuildType;
import org.gradle.nativeplatform.Flavor;
import org.gradle.nativeplatform.NativeBinarySpec;
import org.gradle.nativeplatform.platform.NativePlatform;
public class DependencySpecExtension {
private List<ETNativeDepSet> sets;
private final Project project;
public List<ETNativeDepSet> getSets() {
return sets;
}
public void setSets(List<ETNativeDepSet> sets) {
this.sets = sets;
}
public Project getProject() {
return project;
}
public DependencySpecExtension(Project project) {
sets = new ArrayList<>();
this.project = project;
}
public ETNativeDepSet find(String name, NativeBinarySpec binary) {
return find(name, binary.getFlavor(), binary.getBuildType(), binary.getTargetPlatform());
}
public ETNativeDepSet find(String name, Flavor flavor, BuildType buildType, NativePlatform targetPlatform) {
Optional<ETNativeDepSet> first = sets.stream().filter(x -> x.getName().equals(name) && x.appliesTo(flavor, buildType, targetPlatform)).findFirst();
if (first.isPresent()) {
return first.get();
} else {
return null;
}
}
}
| 29.531915
| 155
| 0.694524
|
773ba58dcada93b0253a1073f64bfa96723d4a2f
| 9,382
|
/**
* Copyright 2004-2014 The Kuali Foundation
*
* Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
*
* 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.kuali.kpme.tklm.time.timesummary;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.json.simple.JSONValue;
import org.kuali.kpme.tklm.api.time.timesummary.TimeSummaryContract;
import org.kuali.kpme.tklm.leave.summary.LeaveSummaryRow;
public class TimeSummary implements Serializable, TimeSummaryContract {
private static final long serialVersionUID = -1292273625423289154L;
private Map<Integer,String> timeSummaryHeader;
private BigDecimal grandTotal= BigDecimal.ZERO;
private List<String> summaryHeader = new ArrayList<String>();
private List<EarnGroupSection> sections = new ArrayList<EarnGroupSection>();
private Map<String, List<EarnGroupSection>> weeklySections = new LinkedHashMap<String, List<EarnGroupSection>>();
private List<LeaveSummaryRow> maxedLeaveRows = new ArrayList<LeaveSummaryRow>();
private List<BigDecimal> workedHours = new ArrayList<BigDecimal>();
private Map<String, BigDecimal> weekTotalMap = new LinkedHashMap<String, BigDecimal>();
private Map<String, BigDecimal> flsaWeekTotalMap = new LinkedHashMap<String, BigDecimal>();
private Map<String, Map<Integer, BigDecimal>> weeklyWorkedHours = new LinkedHashMap<String, Map<Integer, BigDecimal>>();
private Map<String, Map<Integer, Boolean>> weeklyClockLogs = new LinkedHashMap<String, Map<Integer, Boolean>>();
private Map<String, String> weekDates = new LinkedHashMap<String, String>();
private Map<String, Integer> weekDateToCalendarDayInt = new HashMap<>();
public BigDecimal getGrandTotal() {
return grandTotal;
}
public void setGrandTotal(BigDecimal grandTotal) {
this.grandTotal = grandTotal;
}
public List<String> getSummaryHeader() {
return summaryHeader;
}
public void setSummaryHeader(List<String> summaryHeader) {
this.summaryHeader = summaryHeader;
}
public List<EarnGroupSection> getSections() {
return sections;
}
public void setSections(List<EarnGroupSection> sections) {
this.sections = sections;
}
public List<BigDecimal> getWorkedHours() {
return workedHours;
}
public void setWorkedHours(List<BigDecimal> workedHours) {
this.workedHours = workedHours;
}
public String toJsonString() {
List<Map<String, Object>> earnGroupSections = new ArrayList<Map<String, Object>>();
//Lets add a fake EarnGroupSection for worked hours!!!
Map<String, Object> wkHours = new HashMap<String, Object>();
wkHours.put("totals", getWorkedHours());
wkHours.put("earnGroup", "Worked Hours");
wkHours.put("earnCodeSections", new HashMap<String, Object>());
for (EarnGroupSection earnGroupSection : this.sections) {
List<Map<String, Object>> earnCodeSections = new ArrayList<Map<String, Object>>();
Map<String, Object> egs = new TreeMap<String, Object>();
egs.put("earnGroup", earnGroupSection.getEarnGroup());
egs.put("totals", earnGroupSection.getTotals());
for (EarnCodeSection earnCodeSection : earnGroupSection.getEarnCodeSections()) {
Map<String, Object> ecs = new TreeMap<String, Object>();
ecs.put("earnCode", earnCodeSection.getEarnCode());
ecs.put("desc", earnCodeSection.getDescription());
ecs.put("totals", earnCodeSection.getTotals());
ecs.put("isAmountEarnCode", earnCodeSection.getIsAmountEarnCode());
ecs.put("assignmentSize", earnCodeSection.getAssignmentsRows().size() + 1);
ecs.put("earnGroup", earnGroupSection.getEarnGroup());
ecs.put("totals", earnGroupSection.getTotals());
List<Map<String, Object>> assignmentRows = new ArrayList<Map<String, Object>>();
for (AssignmentRow assignmentRow : earnCodeSection.getAssignmentsRows()) {
Map<String, Object> ar = new TreeMap<String, Object>();
ar.put("descr", assignmentRow.getDescr());
ar.put("assignmentKey", assignmentRow.getAssignmentKey());
ar.put("cssClass", assignmentRow.getCssClass());
ar.put("earnCode", earnCodeSection.getEarnCode());
List<Map<String, Object>> assignmentColumns = new ArrayList<Map<String, Object>>();
for (AssignmentColumn assignmentColumn : assignmentRow.getAssignmentColumns().values()) {
Map<String, Object> ac = new TreeMap<String, Object>();
ac.put("cssClass", assignmentColumn.getCssClass());
ac.put("amount", assignmentColumn.getAmount());
ac.put("total", assignmentColumn.getTotal());
ac.put("isWeeklyTotal", assignmentColumn.isWeeklyTotal());
assignmentColumns.add(ac);
}
ar.put("assignmentColumns", assignmentColumns);
assignmentRows.add(ar);
}
ecs.put("assignmentRows", assignmentRows);
List<Map<String, Object>> weekTotalRows = new java.util.LinkedList<Map<String, Object>>();
for(String key : this.weekTotalMap.keySet()) {
Map<String, Object> wt = new HashMap<String, Object>();
wt.put("weekName", key);
wt.put("weekTotal", weekTotalMap.get(key));
weekTotalRows.add(wt);
}
ecs.put("weekTotals", weekTotalRows);
List<Map<String, Object>> flsaWeekTotalRows = new java.util.LinkedList<Map<String, Object>>();
for(String key : this.flsaWeekTotalMap.keySet()) {
Map<String, Object> wt = new HashMap<String, Object>();
wt.put("weekName", key);
wt.put("weekTotal", flsaWeekTotalMap.get(key));
flsaWeekTotalRows.add(wt);
}
ecs.put("flsaWeekTotals", flsaWeekTotalRows);
earnCodeSections.add(ecs);
}
egs.put("earnCodeSections", earnCodeSections);
earnGroupSections.add(egs);
}
earnGroupSections.add(wkHours);
return JSONValue.toJSONString(earnGroupSections);
}
public List<LeaveSummaryRow> getMaxedLeaveRows() {
return maxedLeaveRows;
}
public void setMaxedLeaveRows(List<LeaveSummaryRow> maxedLeaveRows) {
this.maxedLeaveRows = maxedLeaveRows;
}
/**
* @return the weekTotalMap
*/
public Map<String, BigDecimal> getWeekTotalMap() {
return weekTotalMap;
}
/**
* @param weekTotalMap the weekTotalMap to set
*/
public void setWeekTotalMap(Map<String, BigDecimal> weekTotalMap) {
this.weekTotalMap = weekTotalMap;
}
public Map<String, BigDecimal> getFlsaWeekTotalMap() {
return flsaWeekTotalMap;
}
public void setFlsaWeekTotalMap(Map<String, BigDecimal> flsaWeekTotalMap) {
this.flsaWeekTotalMap = flsaWeekTotalMap;
}
public Map<String, String> getWeekDates() {
return weekDates;
}
public void setWeekDates(Map<String, String> weekDates) {
this.weekDates = weekDates;
}
public Map<String, List<EarnGroupSection>> getWeeklySections() {
return weeklySections;
}
public void setWeeklySections(Map<String, List<EarnGroupSection>> weeklySections) {
this.weeklySections = weeklySections;
}
public Map<String, Map<Integer, BigDecimal>> getWeeklyWorkedHours() {
return weeklyWorkedHours;
}
public void setWeeklyWorkedHours(
Map<String, Map<Integer, BigDecimal>> weeklyWorkedHours) {
this.weeklyWorkedHours = weeklyWorkedHours;
}
public Map<Integer, String> getTimeSummaryHeader() {
return timeSummaryHeader;
}
public void setTimeSummaryHeader(Map<Integer, String> timeSummaryHeader) {
this.timeSummaryHeader = timeSummaryHeader;
}
public Map<String, Integer> getWeekDateToCalendarDayInt() {
return weekDateToCalendarDayInt;
}
public void setWeekDateToCalendarDayInt(Map<String, Integer> weekDateToCalendarDayInt) {
this.weekDateToCalendarDayInt = weekDateToCalendarDayInt;
}
public Map<String, Map<Integer, Boolean>> getWeeklyClockLogs() {
return weeklyClockLogs;
}
public void setWeeklyClockLogs(
Map<String, Map<Integer, Boolean>> weeklyClockLogs) {
this.weeklyClockLogs = weeklyClockLogs;
}
}
| 40.969432
| 122
| 0.656683
|
a64ba444e48c84e6e0fb93e5d4053f2d6dce42bb
| 788
|
package java007;
import java.util.Scanner;
public class P06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 0;
System.out.println("Please input a text");
Scanner sc = new Scanner(System.in);
String text = sc.nextLine();
String cutText[] = text.split(" ");
String cutOneText[] = text.split("");
System.out.println("Please input a word");
String word = sc.nextLine();
String cutWord[] = word.split(" ");
if (word.length() == 1) {
for (int i = 0; i < cutOneText.length; i++) {
if ((cutOneText[i].contains(cutWord[0]))) {
count++;
}
}
} else {
for (int i = 0; i < cutText.length; i++) {
if ((cutText[i].contains(cutWord[0]))) {
count++;
}
}
}
System.out.println(count);
}
}
| 21.297297
| 48
| 0.59264
|
75f09a4837bf94e156d809ebc0ff5e68e0224b6a
| 847
|
package cn.rzedu.sf.user.mapper;
import cn.rzedu.sf.user.entity.UserLoginLog;
import cn.rzedu.sf.user.vo.UserLoginLogVO;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用户每日登陆记录 Mapper 接口
*
* @author Blade
* @since 2020-09-24
*/
public interface UserLoginLogMapper extends BaseMapper<UserLoginLog> {
/**
* 自定义分页
*
* @param page
* @param userLoginLog
* @return
*/
List<UserLoginLogVO> selectUserLoginLogPage(IPage page, UserLoginLogVO userLoginLog);
/**
* 用户登录记录
* @param userId
* @return
*/
List<UserLoginLog> findByUserId(Integer userId);
/**
* 用户某日登录记录
* @param userId
* @param loginTime
* @return
*/
UserLoginLog findByFormatTime(Integer userId, LocalDateTime loginTime);
}
| 19.25
| 86
| 0.727273
|
b084c32d6e930640c586caff36439125b1b15b6e
| 1,440
|
package com.huazie.fleaframework.jersey.server.filter;
import com.huazie.fleaframework.common.slf4j.FleaLogger;
import com.huazie.fleaframework.common.slf4j.impl.FleaLoggerProxy;
import com.huazie.fleaframework.jersey.common.JerseyXmlDigesterHelper;
import com.huazie.fleaframework.jersey.common.filter.config.FleaJerseyFilterConfig;
import com.huazie.fleaframework.jersey.common.filter.config.Jersey;
import org.junit.Test;
/**
* <p> Flea Jersey Filter 配置单元测试类 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public class FleaJerseyFilterConfigTest {
private static final FleaLogger LOGGER = FleaLoggerProxy.getProxyInstance(FleaJerseyFilterConfigTest.class);
@Test
public void testJerseyFilter() {
Jersey jersey = JerseyXmlDigesterHelper.getInstance().getJersey();
LOGGER.debug("config={}", jersey);
}
@Test
public void testJerseyFilterConfigOfBefore() {
LOGGER.debug("before={}", FleaJerseyFilterConfig.getBeforeFilters());
}
@Test
public void testJerseyFilterConfigOfService() {
LOGGER.debug("service={}", FleaJerseyFilterConfig.getServiceFilters());
}
@Test
public void testJerseyFilterConfigOfAfter() {
LOGGER.debug("after={}", FleaJerseyFilterConfig.getAfterFilters());
}
@Test
public void testJerseyFilterConfigOfError() {
LOGGER.debug("error={}", FleaJerseyFilterConfig.getErrorFilters());
}
}
| 30.638298
| 112
| 0.733333
|
78b05cc669d22dd5dde542bb32b01c3420face41
| 1,234
|
package com.mixmaru.my_contracts_j.domain.repository;
import com.mixmaru.my_contracts_j.domain.entity.CorporationUserEntity;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class CorporationUserRepositoryTest {
@Autowired
private CorporationUserRepository repository;
@Test
@Transactional
void save() {
// 準備
var now = ZonedDateTime.of(2021,1,2,3,4,5,666666666, ZoneId.of("Asia/Tokyo"));
var entity = CorporationUserEntity.createNew("会社", "社長", "担当", now);
// 実行
var savedEntity = repository.save(entity);
// 検証
assertNotNull(savedEntity.getId());
assertEquals("会社", savedEntity.getCorporationName());
assertEquals("社長", savedEntity.getPresidentName());
assertEquals("担当", savedEntity.getContactPersonName());
assertEquals(now, savedEntity.getCreatedAt());
assertEquals(now, savedEntity.getUpdatedAt());
}
}
| 32.473684
| 86
| 0.723663
|
58d6aa4e8cdbeda0f1eb5e0612e68f9d53f7c2e2
| 24,411
|
/*
* Copyright 2018 Netflix, Inc.
*
* 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 com.netflix.titus.master.loadbalancer.service;
import java.time.Duration;
import java.time.Instant;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import com.google.common.collect.Sets;
import com.netflix.spectator.api.BasicTag;
import com.netflix.spectator.api.Counter;
import com.netflix.spectator.api.Id;
import com.netflix.spectator.api.Registry;
import com.netflix.spectator.api.Tag;
import com.netflix.spectator.api.patterns.PolledMeter;
import com.netflix.titus.api.connector.cloud.LoadBalancer;
import com.netflix.titus.api.connector.cloud.LoadBalancerConnector;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.loadbalancer.model.JobLoadBalancer;
import com.netflix.titus.api.loadbalancer.model.JobLoadBalancerState;
import com.netflix.titus.api.loadbalancer.model.LoadBalancerTarget;
import com.netflix.titus.api.loadbalancer.model.LoadBalancerTarget.State;
import com.netflix.titus.api.loadbalancer.model.LoadBalancerTargetState;
import com.netflix.titus.api.loadbalancer.store.LoadBalancerStore;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.rx.batch.Priority;
import com.netflix.titus.common.util.spectator.ContinuousSubscriptionMetrics;
import com.netflix.titus.common.util.spectator.SpectatorExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Completable;
import rx.Observable;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import static com.netflix.titus.api.jobmanager.service.JobManagerException.ErrorCode.JobNotFound;
import static com.netflix.titus.master.MetricConstants.METRIC_LOADBALANCER;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.partitioningBy;
public class DefaultLoadBalancerReconciler implements LoadBalancerReconciler {
private static final Logger logger = LoggerFactory.getLogger(DefaultLoadBalancerReconciler.class);
private static final String METRIC_RECONCILER = METRIC_LOADBALANCER + "reconciliation";
private static final Runnable NOOP = () -> {
};
/**
* how many store calls (both updates and deletes) are allowed concurrently during cleanup (GC)
*/
private static final int MAX_ORPHAN_CLEANUP_CONCURRENCY = 100;
private final ConcurrentMap<LoadBalancerTarget, Instant> ignored = new ConcurrentHashMap<>();
// this is not being accessed by multiple threads at the same time, but we still use a ConcurrentMap to ensure
// visibility across multiple reconciliation runs, which may run on different threads
private final Set<JobLoadBalancer> markedAsOrphan = ConcurrentHashMap.newKeySet();
private final LoadBalancerStore store;
private final LoadBalancerConnector connector;
private final LoadBalancerJobOperations jobOperations;
// TODO: make dynamic and switch to a Supplier<Long>
private final long delayMs;
private final Supplier<Long> timeoutMs;
private final Runnable afterReconciliation;
private final Registry registry;
private final Scheduler scheduler;
private final Counter registerCounter;
private final Counter deregisterCounter;
private final Counter removeCounter;
private final ContinuousSubscriptionMetrics fullReconciliationMetrics;
private final ContinuousSubscriptionMetrics orphanUpdateMetrics;
private final ContinuousSubscriptionMetrics removeMetrics;
private final ContinuousSubscriptionMetrics removeTargetsMetrics;
private final ContinuousSubscriptionMetrics registeredIpsMetrics;
private final Id ignoredMetricsId;
private final Id orphanMetricsId;
DefaultLoadBalancerReconciler(LoadBalancerConfiguration configuration,
LoadBalancerStore store,
LoadBalancerConnector connector,
LoadBalancerJobOperations loadBalancerJobOperations,
Registry registry,
Scheduler scheduler) {
this(configuration, store, connector, loadBalancerJobOperations, NOOP, registry, scheduler);
}
DefaultLoadBalancerReconciler(LoadBalancerConfiguration configuration,
LoadBalancerStore store,
LoadBalancerConnector connector,
LoadBalancerJobOperations loadBalancerJobOperations,
Runnable afterReconciliation,
Registry registry,
Scheduler scheduler) {
this.store = store;
this.connector = connector;
this.jobOperations = loadBalancerJobOperations;
this.delayMs = configuration.getReconciliationDelayMs();
this.timeoutMs = configuration::getReconciliationTimeoutMs;
this.afterReconciliation = afterReconciliation;
this.registry = registry;
this.scheduler = scheduler;
List<Tag> tags = Collections.singletonList(new BasicTag("class", DefaultLoadBalancerReconciler.class.getSimpleName()));
final Id updatesCounterId = registry.createId(METRIC_RECONCILER + ".updates", tags);
this.registerCounter = registry.counter(updatesCounterId.withTag("operation", "register"));
this.deregisterCounter = registry.counter(updatesCounterId.withTag("operation", "deregister"));
this.removeCounter = registry.counter(updatesCounterId.withTag("operation", "remove"));
this.fullReconciliationMetrics = SpectatorExt.continuousSubscriptionMetrics(METRIC_RECONCILER + ".full", tags, registry);
this.orphanUpdateMetrics = SpectatorExt.continuousSubscriptionMetrics(METRIC_RECONCILER + ".orphanUpdates", tags, registry);
this.removeMetrics = SpectatorExt.continuousSubscriptionMetrics(METRIC_RECONCILER + ".remove", tags, registry);
this.removeTargetsMetrics = SpectatorExt.continuousSubscriptionMetrics(METRIC_RECONCILER + ".removeTargets", tags, registry);
this.registeredIpsMetrics = SpectatorExt.continuousSubscriptionMetrics(METRIC_RECONCILER + ".getRegisteredIps", tags, registry);
this.ignoredMetricsId = registry.createId(METRIC_RECONCILER + ".ignored", tags);
this.orphanMetricsId = registry.createId(METRIC_RECONCILER + ".orphan", tags);
PolledMeter.using(registry).withId(ignoredMetricsId).monitorSize(ignored);
PolledMeter.using(registry).withId(orphanMetricsId).monitorSize(markedAsOrphan);
}
@Override
public void activateCooldownFor(LoadBalancerTarget target, long period, TimeUnit unit) {
Duration periodDuration = Duration.ofMillis(unit.toMillis(period));
logger.debug("Setting a cooldown of {} for target {}", periodDuration, target);
Instant untilWhen = Instant.ofEpochMilli(scheduler.now()).plus(periodDuration);
ignored.put(target, untilWhen);
}
@Override
public void shutdown() {
orphanUpdateMetrics.remove();
removeMetrics.remove();
registeredIpsMetrics.remove();
PolledMeter.remove(registry, ignoredMetricsId);
PolledMeter.remove(registry, orphanMetricsId);
}
@Override
public Observable<TargetStateBatchable> events() {
Observable<Map.Entry<String, List<JobLoadBalancerState>>> cleanupOrphansAndSnapshot = updateOrphanAssociations()
.andThen(snapshotAssociationsByLoadBalancer());
// full reconciliation run
Observable<TargetStateBatchable> updatesForAll = cleanupOrphansAndSnapshot
.flatMap(entry -> reconcile(entry.getKey(), entry.getValue()), 1)
.compose(ObservableExt.subscriptionTimeout(timeoutMs, TimeUnit.MILLISECONDS, scheduler))
.compose(fullReconciliationMetrics.asObservable())
.doOnError(e -> logger.error("reconciliation failed", e))
.onErrorResumeNext(Observable.empty());
// schedule periodic full reconciliations
return ObservableExt.periodicGenerator(updatesForAll, delayMs, delayMs, TimeUnit.MILLISECONDS, scheduler)
.compose(SpectatorExt.subscriptionMetrics(METRIC_RECONCILER, DefaultLoadBalancerReconciler.class, registry))
.flatMap(iterable -> Observable.from(iterable)
.doOnTerminate(afterReconciliation::run), 1);
}
private Observable<TargetStateBatchable> reconcile(String loadBalancerId, List<JobLoadBalancerState> associations) {
Observable<TargetStateBatchable> updatesForLoadBalancer = connector.getLoadBalancer(loadBalancerId)
// merge known targets
.flatMap(loadBalancer -> ReactorExt.toSingle(
store.getLoadBalancerTargets(loadBalancer.getId())
.collect(Collectors.toSet())
.map(knownTargets -> new LoadBalancerWithKnownTargets(loadBalancer, knownTargets))
))
// the same metrics transformer can be used for all subscriptions only because they are all being
// serialized with flatMap(maxConcurrent: 1)
.compose(registeredIpsMetrics.asSingle())
.flatMapObservable(loadBalancerTargets -> updatesFor(loadBalancerTargets, associations));
return updatesForLoadBalancer
.doOnError(e -> logger.error("Error while reconciling load balancer {}", loadBalancerId, e))
.onErrorResumeNext(Observable.empty());
}
/**
* Generates a stream of necessary updates based on what jobs are currently associated with a load balancer, the
* ip addresses currently registered on it, and what ips were previously registered with the load balancer.
* <p>
* {@link JobLoadBalancer} associations in the <tt>Dissociated</tt> state will be removed when it is safe to do so,
* i.e.: when there is no more stored state to be cleaned up, and nothing to be deregistered on the load balancer.
*
* @param loadBalancer tuple with ip addresses currently registered on the load balancer, and ip addresses
* previously registered with the load balancer
* @param associations jobs currently associated to the load balancer
*/
private Observable<TargetStateBatchable> updatesFor(LoadBalancerWithKnownTargets loadBalancer,
List<JobLoadBalancerState> associations) {
Instant now = now();
ReconciliationUpdates updates = (loadBalancer.current.getState().equals(LoadBalancer.State.ACTIVE)) ?
updatesForActiveLoadBalancer(loadBalancer, associations)
: updatesForRemovedLoadBalancer(loadBalancer, associations);
Completable cleanupTargets = (!updates.toRemove.isEmpty()) ?
ReactorExt.toCompletable(store.removeDeregisteredTargets(updates.toRemove))
// bring processing back the the Rx threads, otherwise it happens in the C* driver threadpool
.observeOn(Schedulers.computation())
.doOnSubscribe(ignored -> logger.info("Cleaning up {} deregistered targets for load balancer {}",
updates.toRemove.size(), loadBalancer.current.getId()))
.compose(removeTargetsMetrics.asCompletable())
.doOnError(e -> logger.error("Error while cleaning up targets for " + loadBalancer.current.getId(), e))
.onErrorComplete()
: Completable.complete();
// clean up dissociated entries only if it is safe: all targets have been deregistered and there is nothing to be removed
Completable cleanupDissociated = (updates.toDeregister.isEmpty() && updates.toRemove.isEmpty()) ?
Completable.mergeDelayError(removeAllDissociated(associations), MAX_ORPHAN_CLEANUP_CONCURRENCY)
.doOnSubscribe(ignored -> logger.debug("Cleaning up dissociated jobs for load balancer {}", loadBalancer.current.getId()))
.compose(removeMetrics.asCompletable())
.doOnError(e -> logger.error("Error while cleaning up associations for " + loadBalancer.current.getId(), e))
.onErrorComplete()
: Completable.complete();
Observable<TargetStateBatchable> updatesForLoadBalancer = Observable.from(CollectionsExt.merge(
withState(now, updates.toRegister, State.REGISTERED),
withState(now, updates.toDeregister, State.DEREGISTERED)
)).filter(this::isNotIgnored);
return Completable.merge(cleanupTargets, cleanupDissociated)
.andThen(updatesForLoadBalancer);
}
private ReconciliationUpdates updatesForActiveLoadBalancer(LoadBalancerWithKnownTargets loadBalancer, List<JobLoadBalancerState> associations) {
Set<LoadBalancerTarget> shouldBeRegistered = associations.stream()
.filter(JobLoadBalancerState::isStateAssociated)
.flatMap(association -> targetsForJobSafe(association).stream())
.collect(Collectors.toSet());
Set<LoadBalancerTarget> toRegister = shouldBeRegistered.stream()
.filter(target -> !loadBalancer.current.getRegisteredIps().contains(target.getIpAddress()))
.collect(Collectors.toSet());
// we will force deregistration of inconsistent entries to force their state to be updated
Set<LoadBalancerTarget> inconsistentStoredState = loadBalancer.knownTargets.stream()
.filter(target -> target.getState().equals(State.REGISTERED) &&
!shouldBeRegistered.contains(target.getLoadBalancerTarget())
)
.map(LoadBalancerTargetState::getLoadBalancerTarget)
.collect(Collectors.toSet());
Set<LoadBalancerTarget> shouldBeDeregisteredFromStoredState = loadBalancer.knownTargets.stream()
.filter(target -> target.getState().equals(State.DEREGISTERED) &&
// filter out cases where job state hasn't fully propagated yet
!shouldBeRegistered.contains(target.getLoadBalancerTarget())
)
.map(LoadBalancerTargetState::getLoadBalancerTarget)
.collect(Collectors.toSet());
// Split what should be deregistered in:
// 1. what needs to be deregistered (and is still registered in the loadbalancer)
// 2. what state can be GCed because it has been already deregistered
Map<Boolean, Set<LoadBalancerTarget>> toDeregisterCurrentInLoadBalancer = shouldBeDeregisteredFromStoredState.stream()
.collect(partitioningBy(
target -> loadBalancer.current.getRegisteredIps().contains(target.getIpAddress()),
Collectors.toSet()
));
Set<LoadBalancerTarget> toDeregister = Sets.union(toDeregisterCurrentInLoadBalancer.get(true), inconsistentStoredState);
Set<LoadBalancerTarget> toRemove = toDeregisterCurrentInLoadBalancer.get(false);
return new ReconciliationUpdates(loadBalancer.current.getId(), toRegister, toDeregister, toRemove);
}
private ReconciliationUpdates updatesForRemovedLoadBalancer(LoadBalancerWithKnownTargets loadBalancer, List<JobLoadBalancerState> associations) {
logger.warn("Load balancer is gone, ignoring its associations (marking them to be GCed later), and removing known state for its targets: {}",
loadBalancer.current.getId());
for (JobLoadBalancerState association : associations) {
if (association.isStateAssociated()) {
logger.info("Marking association as orphan: {}", association.getJobLoadBalancer());
markedAsOrphan.add(association.getJobLoadBalancer());
}
}
// we will force deregistration of everything that was marked as REGISTERED to force its state to be updated
Map<Boolean, Set<LoadBalancerTarget>> registeredOrNot = loadBalancer.knownTargets.stream()
.collect(partitioningBy(
target -> target.getState().equals(State.REGISTERED),
mapping(LoadBalancerTargetState::getLoadBalancerTarget, Collectors.toSet())
));
Set<LoadBalancerTarget> toDeregister = registeredOrNot.get(true); // all REGISTERED
Set<LoadBalancerTarget> toRemove = registeredOrNot.get(false); // all DEREGISTERED
return new ReconciliationUpdates(loadBalancer.current.getId(), Collections.emptySet(), toDeregister, toRemove);
}
private boolean isNotIgnored(TargetStateBatchable update) {
return !ignored.containsKey(update.getIdentifier());
}
private List<LoadBalancerTarget> targetsForJobSafe(JobLoadBalancerState association) {
try {
return jobOperations.targetsForJob(association.getJobLoadBalancer());
} catch (RuntimeException e) {
if (JobManagerException.hasErrorCode(e, JobNotFound)) {
logger.warn("Job is gone, ignoring its association and marking it to be GCed later {}", association);
markedAsOrphan.add(association.getJobLoadBalancer());
} else {
logger.error("Ignoring association, unable to fetch targets for {}", association, e);
}
return Collections.emptyList();
}
}
private Observable<Completable> removeAllDissociated(List<JobLoadBalancerState> associations) {
final List<Completable> removeOperations = associations.stream()
.filter(JobLoadBalancerState::isStateDissociated)
.map(JobLoadBalancerState::getJobLoadBalancer)
.map(association ->
store.removeLoadBalancer(association)
// bring processing back the the Rx threads, otherwise it happens in the C* driver threadpool
.observeOn(Schedulers.computation())
.doOnSubscribe(ignored -> logger.info("Removing dissociated {}", association))
.doOnError(e -> logger.error("Failed to remove {}", association, e))
.onErrorComplete()
).collect(Collectors.toList());
return Observable.from(removeOperations);
}
private List<TargetStateBatchable> withState(Instant instant, Collection<LoadBalancerTarget> targets, State state) {
return targets.stream()
.map(target -> new TargetStateBatchable(Priority.LOW, instant, new LoadBalancerTargetState(target, state)))
.collect(Collectors.toList());
}
/**
* @return emit loadBalancerId -> listOfAssociation pairs to subscribers
*/
private Observable<Map.Entry<String, List<JobLoadBalancerState>>> snapshotAssociationsByLoadBalancer() {
return Observable.defer(() -> {
cleanupExpiredIgnored();
logger.debug("Snapshotting current associations");
Set<Map.Entry<String, List<JobLoadBalancerState>>> pairs = store.getAssociations().stream()
.collect(Collectors.groupingBy(JobLoadBalancerState::getLoadBalancerId))
.entrySet();
return Observable.from(pairs);
});
}
private void cleanupExpiredIgnored() {
Instant now = Instant.ofEpochMilli(scheduler.now());
ignored.forEach((target, untilWhen) -> {
if (untilWhen.isAfter(now)) {
return;
}
if (ignored.remove(target, untilWhen) /* do not remove when changed */) {
logger.debug("Cooldown expired for target {}", target);
}
});
}
/**
* set previously marked orphan associations (their jobs are gone) as <tt>Dissociated</tt>.
*/
private Completable updateOrphanAssociations() {
Observable<Completable> updateOperations = Observable.from(markedAsOrphan).map(marked -> {
if (jobOperations.getJob(marked.getJobId()).isPresent()) {
logger.warn("Not updating an association that was previously marked as orphan, but now contains an existing job: {}", marked);
return Completable.complete();
}
return store.addOrUpdateLoadBalancer(marked, JobLoadBalancer.State.DISSOCIATED)
// bring processing back the the Rx threads, otherwise it happens in the C* driver threadpool
.observeOn(Schedulers.computation())
.doOnSubscribe(ignored -> logger.info("Setting orphan association as Dissociated: {}", marked))
.doOnError(e -> logger.error("Failed to update to Dissociated {}", marked, e));
});
// do as much as possible and swallow errors since future reconciliations will mark orphan associations again
return Completable.mergeDelayError(updateOperations, MAX_ORPHAN_CLEANUP_CONCURRENCY)
.doOnSubscribe(s -> logger.debug("Updating orphan associations"))
.compose(orphanUpdateMetrics.asCompletable())
.onErrorComplete()
.doOnTerminate(markedAsOrphan::clear);
}
private Instant now() {
return Instant.ofEpochMilli(scheduler.now());
}
private static class LoadBalancerWithKnownTargets {
private final LoadBalancer current;
/**
* Targets that have been previously registered by us.
*/
private final Set<LoadBalancerTargetState> knownTargets;
private LoadBalancerWithKnownTargets(LoadBalancer current, Set<LoadBalancerTargetState> knownTargets) {
this.current = current;
this.knownTargets = knownTargets;
}
}
private class ReconciliationUpdates {
private final String loadBalancerId;
private final Set<LoadBalancerTarget> toRegister;
private final Set<LoadBalancerTarget> toDeregister;
private final Set<LoadBalancerTarget> toRemove;
private ReconciliationUpdates(String loadBalancerId, Set<LoadBalancerTarget> toRegister,
Set<LoadBalancerTarget> toDeregister, Set<LoadBalancerTarget> toRemove) {
this.loadBalancerId = loadBalancerId;
this.toRegister = toRegister;
this.toDeregister = toDeregister;
this.toRemove = toRemove;
report();
}
private void report() {
boolean found = false;
if (!toRegister.isEmpty()) {
found = true;
registerCounter.increment(toRegister.size());
}
if (!toDeregister.isEmpty()) {
found = true;
deregisterCounter.increment(toDeregister.size());
}
if (!toRemove.isEmpty()) {
found = true;
removeCounter.increment(toRemove.size());
}
if (found) {
logger.info("Reconciliation for load balancer {} found targets to to be registered: {}, to be deregistered: {}, to be removed: {}",
loadBalancerId, toRegister.size(), toDeregister.size(), toRemove.size());
}
}
}
}
| 53.887417
| 149
| 0.678874
|
f1a195ea6b9f19e9c0c3cdded0862c897dda467f
| 617
|
package com.br.springreactivewebflux.application.ports.out;
import com.br.springreactivewebflux.adapter.outbound.database.entity.ProdutoDocumento;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.UUID;
public interface ProdutoServiceRepositoryOutPort {
Flux<ProdutoDocumento> consultarTodos();
Mono<ProdutoDocumento> consultarPorId(UUID uuid);
Mono<ProdutoDocumento> salvarProdutoDocumento(ProdutoDocumento produtoDocumento);
Mono<Void> deleteProdutoPorId(UUID uuid);
Mono<ProdutoDocumento> atualizarProdutoDocumento(ProdutoDocumento produtoDocumento);
}
| 41.133333
| 88
| 0.833063
|
89fce3143c9b042017104036e15edafe9014109a
| 2,421
|
/** Copyright © 2018, Okta, Inc.
*
* Licensed under the MIT license, the "License";
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/MIT
*
* 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 com.okta.scim.controllers;
import com.okta.scim.database.*;
import com.okta.scim.models.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import java.util.List;
/**
* URL route (root)/ to userDisplay home page
*/
@Controller
@RequestMapping("/")
public class HomeController {
private UserDatabase uDb;
private GroupDatabase gDb;
private TransactionDatabase tDb;
private RequestDatabase rDb;
private GroupMembershipDatabase gmDb;
@Autowired
public HomeController(
UserDatabase uDb,
GroupDatabase gDb,
TransactionDatabase tDb,
RequestDatabase rDb,
GroupMembershipDatabase gmDb) {
this.uDb = uDb;
this.gDb = gDb;
this.tDb = tDb;
this.rDb = rDb;
this.gmDb = gmDb;
}
/**
* Outputs all active users, groups and transaction logs to web view
* @param model UI Model
* @return HTML page to render by name
*/
@RequestMapping(method = RequestMethod.GET)
public String home(ModelMap model) {
List<User> users = uDb.findAll();
List<Group> groups = gDb.findAll();
List<Transaction> transactions = tDb.findAll();
List<Request> requests = rDb.findAll();
List<GroupMembership> groupMemberships = gmDb.findAll();
model.addAttribute("users", users);
model.addAttribute("groups", groups);
model.addAttribute("transactions", transactions);
model.addAttribute("requests", requests);
model.addAttribute("groupMemberships", groupMemberships);
return "home";
}
}
| 32.716216
| 76
| 0.687319
|
70c94adb942448e7737f6384e063fb38f66547eb
| 735
|
package com.luxoft.mx.tool.ui.views.empty;
import com.vaadin.flow.component.littemplate.LitTemplate;
import com.vaadin.flow.router.Route;
import com.vaadin.flow.router.PageTitle;
import com.luxoft.mx.tool.ui.views.MainLayout;
import com.vaadin.flow.router.RouteAlias;
import com.vaadin.flow.component.Tag;
import com.vaadin.flow.component.dependency.JsModule;
@PageTitle("Empty")
@Route(value = "empty", layout = MainLayout.class)
@RouteAlias(value = "", layout = MainLayout.class)
@Tag("empty-view")
@JsModule("./views/empty/empty-view.ts")
public class EmptyView extends LitTemplate {
// This is the Java companion file of a design
// You can find the design file inside /frontend/views/
public EmptyView() {
}
}
| 30.625
| 59
| 0.755102
|
3b189d04691834522d9d167a418f1469d9eec110
| 393
|
package design.pattern.by.jpsoroulas._3_beharioral._4_chain;
import lombok.Data;
@Data
public class ItSupportRequest {
private RequestType type;
private boolean handled = false;
public ItSupportRequest() {
this.type = RequestType.LEVEL1;
}
ItSupportRequest(RequestType type) {
this.type = type;
}
public enum RequestType {
LEVEL1, LEVEL2, LEVEL3, LEVEL4
}
}
| 16.375
| 60
| 0.720102
|
8de7c64c84b33f73b99f21b3d596012a647f7f62
| 184
|
package com.github.javahello.erm.generator.core.codegen.ddl;
/**
* 输出 fix ddl
*/
public interface IFixDDL {
/**
* FIX
* @return FIX DDL
*/
ICovDDL fix();
}
| 12.266667
| 60
| 0.576087
|
8500e5c8f7aec36f1752d5d95b248ebc2ffc9a7e
| 1,022
|
package tigeax.customwings.menus.editor.selectvaluemenus.items;
import tigeax.customwings.menus.editor.selectvaluemenus.ParticleSelectMenuPage;
import tigeax.customwings.util.ParticleItem;
import tigeax.customwings.util.menu.ItemClickEvent;
import tigeax.customwings.util.menu.ItemMenu;
import tigeax.customwings.util.menu.MenuItem;
public class ParticleSelectItem extends MenuItem {
ParticleItem particleItem;
public ParticleSelectItem(ParticleItem particleItem) {
this.particleItem = particleItem;
setDisplayName("&f" + particleItem.getName());
setMaterial(particleItem.getMaterial());
}
@Override
public void onItemClick(ItemClickEvent event) {
ItemMenu itemMenu = event.getItemMenu();
if (!(itemMenu instanceof ParticleSelectMenuPage)) {
event.setWillClose(true);
return;
}
ParticleSelectMenuPage menu = (ParticleSelectMenuPage) itemMenu;
menu.getSetting().setValue(particleItem.toString());
}
}
| 29.2
| 79
| 0.732877
|
b3aea872c946fc645efb603005b1a47c4aae69d7
| 1,316
|
/**
* Copyright (C) 2012 Ness Computing, Inc.
*
* 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 com.nesscomputing.migratory.jdbi;
import org.skife.jdbi.v2.Handle;
import org.skife.jdbi.v2.util.IntegerMapper;
public final class JdbiSupport
{
private JdbiSupport()
{
}
public static int execute(final Handle handle, final String query)
{
return handle.createStatement(query).execute();
}
public static int getInteger(final Handle handle, final String query)
{
return handle.createQuery(query)
.map(IntegerMapper.FIRST)
// Work around an *incredibly* obscure bug in hsqldb 1.8.0.x where setMaxRows(1)
// (which first does) will only return 0 (no rows) or 1 (rows) for COUNT(*)
.setMaxRows(0)
.first();
}
}
| 31.333333
| 88
| 0.696809
|
b4caa64d964ff1f7510919299cc56f8d33a0226f
| 1,607
|
/**
*
*/
package states;
import java.util.ArrayList;
import org.jbox2d.common.Vec2;
import org.jbox2d.dynamics.World;
import entities.MoB;
import gfx.SpriteSheet;
import handlers.CollisionListener;
import handlers.GameStateManager;
/**
* @author TofuSensei
*
*/
public class GameBase extends GameState
{
private GameStateManager gsm; // Needed to change states
private World world;
private ArrayList<MoB> mobs; // Holds all entities
public GameBase(GameStateManager gsm)
{
super(gsm);
this.gsm = gsm;
this.pane = gsm.getPane();
this.gc = gsm.getGraphicsContext();
this.world = new World(new Vec2(0.0f, 0.0f));
this.world.setContactListener(new CollisionListener());
this.mobs = new ArrayList<MoB>();
// Test for Sprite insert
MoB test = new MoB(SpriteSheet.getSprite(0, 0, 200.0f), null);
test.setPos(10, 10);
this.mobs.add(test);
this.pane.getChildren().add(test.getSprite());
// Test for Sprite insert
}
@Override
public void handleInput(double delta)
{
// TODO Auto-generated method stub
}
/**
* Update the game logic
*/
@Override
public void update(double delta)
{
for(int i = 0; i < this.mobs.size(); i++)
this.mobs.get(i).update((float)delta);
}
/**
* Render Sprites and textures
*/
@Override
public void render()
{
for(int i = 0; i < this.mobs.size(); i++)
this.mobs.get(i).draw();
}
@Override
public void dispose()
{
// TODO Auto-generated method stub
}
}
| 19.597561
| 71
| 0.616055
|
d2a3378498dbef20753dd1639f283ad3e18bf3a4
| 5,142
|
package sample.utils;
import cinder.app.App;
import cinder.app.Window;
import cinder.params.InterfaceGl;
import org.moe.natj.cxx.CxxObject;
import org.moe.natj.cxx.CxxRuntime;
import org.moe.natj.general.ptr.BoolPtr;
import org.moe.natj.general.ptr.FloatPtr;
import org.moe.natj.general.ptr.IntPtr;
import glm.detail.IVec2;
import std.SharedPtr;
import std.UpdateFn;
import std.Vector;
import java.util.Collection;
import java.util.HashSet;
public class CommonInterfaceGl {
private final SharedPtr<InterfaceGl> mParams;
private final HashSet<CxxObject> optionsInstanceCollection = new HashSet<>();
public CommonInterfaceGl(SharedPtr<Window> window, String title, int width, int height) {
final IVec2 interfaceSize = IVec2.newIVec2(width, height);
final IVec2 interfaceSizePixels = App.toPixels(interfaceSize);
CxxRuntime.delete(interfaceSize);
final std.String _title = std.String.getString(title);
mParams = InterfaceGl.create(window, _title, interfaceSizePixels);
CxxRuntime.delete(interfaceSizePixels);
CxxRuntime.delete(_title);
}
public void finish() {
for (CxxObject cxxObject : optionsInstanceCollection) {
CxxRuntime.delete(cxxObject);
}
optionsInstanceCollection.clear();
}
public InterfaceGl.OptionsInt addParam(String name, String[] enumNames, IntPtr param, boolean readOnly) {
final std.String _name = std.String.getString(name);
final Vector<std.String> _values = vecFromStrings(enumNames);
final InterfaceGl.OptionsInt options = mParams.get().addParam(_name, _values, param, readOnly);
optionsInstanceCollection.add(options);
CxxRuntime.delete(_values);
CxxRuntime.delete(_name);
return options;
}
public InterfaceGl.OptionsInt addParam(String name, String[] enumNames, IntPtr param) {
return addParam(name, enumNames, param, false);
}
public InterfaceGl.OptionsFloat addParam(String name, FloatPtr target, boolean readOnly) {
final std.String _name = std.String.getString(name);
final InterfaceGl.OptionsFloat options = mParams.get().addParam(_name, target, readOnly);
optionsInstanceCollection.add(options);
CxxRuntime.delete(_name);
return options;
}
public InterfaceGl.OptionsFloat addParam(String name, FloatPtr target) {
return addParam(name, target, false);
}
public InterfaceGl.OptionsBool addParam(String name, BoolPtr target, boolean readOnly) {
final std.String _name = std.String.getString(name);
final InterfaceGl.OptionsBool options = mParams.get().addParam(_name, target, readOnly);
optionsInstanceCollection.add(options);
CxxRuntime.delete(_name);
return options;
}
public InterfaceGl.OptionsBool addParam(String name, BoolPtr target) {
return addParam(name, target, false);
}
public InterfaceGl.OptionsInt addParam(String name, IntPtr target, boolean readOnly) {
final std.String _name = std.String.getString(name);
final InterfaceGl.OptionsInt options = mParams.get().addParam(_name, target, readOnly);
optionsInstanceCollection.add(options);
CxxRuntime.delete(_name);
return options;
}
public InterfaceGl.OptionsInt addParam(String name, IntPtr target) {
return addParam(name, target, false);
}
private std.Vector<std.String> vecFromStrings(String... values) {
std.Vector<std.String> vector = std.String.newStringVector();
for (String value : values) {
final std.String string = std.String.getString(value);
vector.push_back(string);
CxxRuntime.delete(string);
}
return vector;
}
public void addSeparator(String name, String optionsStr) {
mParams.get().addSeparator(name, optionsStr);
}
public void addSeparator() {
mParams.get().addSeparator();
}
//! Adds a button that fires \a callback when clicked.
public void addButton(String name, UpdateFn callback, String optionsStr) {
mParams.get().addButton(name, callback, optionsStr);
}
public void addButton(String name, UpdateFn callback) {
mParams.get().addButton(name, callback);
}
//! Draw the interface.
public void draw() {
mParams.get().draw();
}
public void setOptions(String name, String optionsStr) {
mParams.get().setOptions(name, optionsStr);
}
public void setOptions(String name) {
mParams.get().setOptions(name);
}
public void keepOption(InterfaceGl.OptionsBase option) {
final long peer = option._cxx_rt_peer();
for (CxxObject cxxObject : optionsInstanceCollection) {
if (cxxObject._cxx_rt_peer() == peer) {
optionsInstanceCollection.remove(cxxObject);
break;
}
}
}
public void keepAllOptions(Collection<InterfaceGl.OptionsBase> options) {
for (InterfaceGl.OptionsBase option : options) {
keepOption(option);
}
}
}
| 34.979592
| 109
| 0.680086
|
9801cb26c987b8d0ae631781070eb8c95a6beb2c
| 2,843
|
package com.microsoft.bingads.api.test.entities.campaign.read;
import com.microsoft.bingads.api.test.entities.ObjectComparer;
import com.microsoft.bingads.api.test.entities.campaign.BulkCampaignTest;
import com.microsoft.bingads.bulk.entities.BulkCampaign;
import com.microsoft.bingads.campaignmanagement.Setting;
import com.microsoft.bingads.campaignmanagement.ShoppingSetting;
import com.microsoft.bingads.internal.functionalinterfaces.Function;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.*;
@RunWith(Parameterized.class)
public class BulkCampaignReadFromRowValuesSettingsTest extends BulkCampaignTest {
@Parameterized.Parameter(value = 1)
public String storeId;
@Parameterized.Parameter(value = 2)
public String campaignPriority;
@Parameterized.Parameter(value = 3)
public String countryCode;
@Parameterized.Parameter(value = 4)
public List<Setting> expectedResult;
@Parameterized.Parameters
public static Collection<Object[]> data() {
ShoppingSetting setting1 = new ShoppingSetting();
setting1.setStoreId(123L);
setting1.setPriority(1);
setting1.setSalesCountryCode("US");
setting1.setType("ShoppingSetting");
ShoppingSetting setting2 = new ShoppingSetting();
setting2.setStoreId(2147483647L);
setting2.setPriority(2);
setting2.setSalesCountryCode("CHINA");
setting2.setType("ShoppingSetting");
return Arrays.asList(
new Object[][]{
{"Shopping", "123", "1", "US", Collections.singletonList(setting1)},
{"Shopping", "2147483647", "2", "CHINA", Collections.singletonList(setting2)},
{"SearchAndContent", "", "", "", null},
{"", "", "", "", null},
{"SearchAndContent", "1234", "123", "CANADA", null},
}
);
}
@Test
public void testRead() {
Map<String, String> values = new HashMap<String, String>();
values.put("Campaign Type", datum);
values.put("Store Id", storeId);
values.put("Priority", campaignPriority);
values.put("COUNTRY_CODE", countryCode);
testReadProperty(
values,
this.expectedResult,
new Function<BulkCampaign, List<Setting>>() {
@Override
public List<Setting> apply(BulkCampaign c) {
if (c.getCampaign().getSettings() == null) {
return null;
}
return c.getCampaign().getSettings().getSettings();
}
},
new ObjectComparer<List<Setting>>()
);
}
}
| 35.5375
| 102
| 0.609567
|
c779d1aeb77f79b94b5624f3e4f43b732ac9397b
| 447
|
package org.android.spdy;
import java.util.Map;
public class SpdyDataProvider {
byte[] data;
public boolean finished;
Map<String, String> postBody;
public SpdyDataProvider(byte[] bArr) {
this.finished = true;
this.data = bArr;
this.postBody = null;
}
public SpdyDataProvider(Map<String, String> map) {
this.finished = true;
this.data = null;
this.postBody = map;
}
}
| 20.318182
| 54
| 0.612975
|
235ff5c64cd6d3db08a44fa6f7ed645436adc569
| 247
|
package com.alibaba.fastcreate.adapter;
import com.alibaba.fastcreate.model.ClazzModel;
import java.util.List;
public interface ClazzModelBuild {
ClazzModel buildModel(List list, Object object);
void init(List list, Object object);
}
| 19
| 52
| 0.773279
|
1edf09296f3e6b0d4de5177b162e4454cd94a359
| 2,505
|
package org.mindinformatics.gwt.framework.component.ui.toolbar;
import org.mindinformatics.gwt.framework.src.Application;
import org.mindinformatics.gwt.framework.src.IApplication;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.uibinder.client.UiTemplate;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Image;
/**
* @author Paolo Ciccarese <paolo.ciccarese@gmail.com>
*/
public class ToolbarHorizontalPanel extends Composite implements IToolbarItem {
@UiTemplate("ToolbarHorizontalPanel.ui.xml")
interface Binder extends UiBinder<HorizontalPanel, ToolbarHorizontalPanel> { }
private static final Binder binder = GWT.create(Binder.class);
@UiField HorizontalPanel toolbarHorizontalPanel;
private Image img;
private HTML labelPanel;
private ClickHandler _clickHandler;
private HandlerRegistration iconHandlerRegistration;
private HandlerRegistration labelHandlerRegistration;
public ToolbarHorizontalPanel(IApplication application, ClickHandler clickHandler,
String icon, String label, String tooltip) {
_clickHandler = clickHandler;
initWidget(binder.createAndBindUi(this));
img = new Image(icon);
img.setTitle(tooltip);
//img.setHeight("24px");
//img.setWidth("24px");
labelPanel = new HTML(label);
labelPanel.setTitle(tooltip);
toolbarHorizontalPanel.add(img);
toolbarHorizontalPanel.add(labelPanel);
enable();
}
@Override
public void enable() {
iconHandlerRegistration = img.addClickHandler(_clickHandler);
img.setStyleName(Application.applicationResources.css().button());
labelHandlerRegistration = labelPanel.addClickHandler(_clickHandler);
labelPanel.setStyleName(Application.applicationResources.css().label());
}
@Override
public void disable() {
iconHandlerRegistration.removeHandler();
img.setStyleName(Application.applicationResources.css().disabledButton());
labelHandlerRegistration.removeHandler();
labelPanel.setStyleName(Application.applicationResources.css().disabledLabel());
}
@Override
public void hide() {
toolbarHorizontalPanel.setVisible(false);
}
@Override
public void show() {
toolbarHorizontalPanel.setVisible(true);
}
}
| 30.925926
| 83
| 0.791617
|
4f5c2596ba02fcbeb2ed02c5eea9d4b802862ad7
| 6,563
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.flink.runtime.state.filesystem;
import org.apache.flink.core.fs.FileSystem;
import org.apache.flink.core.fs.Path;
import org.apache.flink.core.fs.RecoverableWriter;
import org.apache.flink.runtime.state.CheckpointMetadataOutputStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import java.io.IOException;
import static org.apache.flink.util.Preconditions.checkNotNull;
/**
* A {@link CheckpointMetadataOutputStream} that writes a specified file and directory, and returns
* a {@link FsCompletedCheckpointStorageLocation} upon closing.
*/
public final class FsCheckpointMetadataOutputStream extends CheckpointMetadataOutputStream {
private static final Logger LOG =
LoggerFactory.getLogger(FsCheckpointMetadataOutputStream.class);
// ------------------------------------------------------------------------
private final Path metadataFilePath;
private final Path exclusiveCheckpointDir;
private final FileSystem fileSystem;
private volatile boolean closed;
private final MetadataOutputStreamWrapper outputStreamWrapper;
public FsCheckpointMetadataOutputStream(
FileSystem fileSystem, Path metadataFilePath, Path exclusiveCheckpointDir)
throws IOException {
this.fileSystem = checkNotNull(fileSystem);
this.metadataFilePath = checkNotNull(metadataFilePath);
this.exclusiveCheckpointDir = checkNotNull(exclusiveCheckpointDir);
this.outputStreamWrapper = getOutputStreamWrapper(fileSystem, metadataFilePath);
}
// ------------------------------------------------------------------------
// I/O
// ------------------------------------------------------------------------
@Override
public final void write(int b) throws IOException {
outputStreamWrapper.getOutput().write(b);
}
@Override
public final void write(@Nonnull byte[] b, int off, int len) throws IOException {
outputStreamWrapper.getOutput().write(b, off, len);
}
@Override
public long getPos() throws IOException {
return outputStreamWrapper.getOutput().getPos();
}
@Override
public void flush() throws IOException {
outputStreamWrapper.getOutput().flush();
}
@Override
public void sync() throws IOException {
outputStreamWrapper.getOutput().sync();
}
// ------------------------------------------------------------------------
// Closing
// ------------------------------------------------------------------------
public boolean isClosed() {
return closed;
}
@Override
public void close() {
if (!closed) {
closed = true;
try {
outputStreamWrapper.close();
outputStreamWrapper.cleanup();
} catch (Throwable t) {
LOG.warn("Could not close the state stream for {}.", metadataFilePath, t);
}
}
}
@Override
public FsCompletedCheckpointStorageLocation closeAndFinalizeCheckpoint() throws IOException {
synchronized (this) {
if (!closed) {
try {
// make a best effort attempt to figure out the size
long size = 0;
try {
size = outputStreamWrapper.getOutput().getPos();
} catch (Exception ignored) {
}
outputStreamWrapper.closeForCommit();
FileStateHandle metaDataHandle = new FileStateHandle(metadataFilePath, size);
return new FsCompletedCheckpointStorageLocation(
fileSystem,
exclusiveCheckpointDir,
metaDataHandle,
metaDataHandle.getFilePath().getParent().toString());
} catch (Exception e) {
try {
outputStreamWrapper.cleanup();
} catch (Exception deleteException) {
LOG.warn(
"Could not delete the checkpoint stream file {}.",
metadataFilePath,
deleteException);
}
throw new IOException(
"Could not flush and close the file system "
+ "output stream to "
+ metadataFilePath
+ " in order to obtain the "
+ "stream state handle",
e);
} finally {
closed = true;
}
} else {
throw new IOException("Stream has already been closed and discarded.");
}
}
}
static MetadataOutputStreamWrapper getOutputStreamWrapper(
final FileSystem fileSystem, final Path metadataFilePath) throws IOException {
if (fileSystem.exists(metadataFilePath)) {
throw new IOException("Target file " + metadataFilePath + " already exists.");
}
try {
RecoverableWriter recoverableWriter = fileSystem.createRecoverableWriter();
return new RecoverableStreamWrapper(recoverableWriter.open(metadataFilePath));
} catch (Throwable throwable) {
LOG.info(
"Cannot create recoverable writer due to {}, will use the ordinary writer.",
throwable.getMessage());
}
return new FSDataOutputStreamWrapper(fileSystem, metadataFilePath);
}
}
| 36.06044
| 99
| 0.571995
|
cc8bc7d505734fc0d9b473c115b4102f663b1120
| 304
|
public class Cat extends Animal {
private final static String MEEOW = "MEEOW";
public Cat(String name, String favouriteFood) {
super(name, favouriteFood);
}
@Override
public String explainSelf() {
return super.baseExplain() + System.lineSeparator() + MEEOW;
}
}
| 23.384615
| 68
| 0.651316
|
4e271900585efa0a5b25fcce28589cda4a672f45
| 795
|
package framework;
public class JSSelect extends JSContainer implements InputField<String> {
public JSSelect(String name) {
super(name, "select");
}
public JSSelect addOption(JSOption option) {
addChild(option);
return this;
}
@Override
public String getValue() {
String val = getAttribute("value");
for (JSContainer opt : getChildren()) {
if (opt.getAttribute("value").equals(val)) {
return ((JSOption) opt).getValue();
}
}
return null;
}
@Override
public void setValue(String val) {
for (JSContainer opt : getChildren()) {
if (opt.getAttribute("value").equals(val)) {
((JSOption) opt).setSelected(true);
}
}
}
@Override
public void setRawValue(String value) {
setAttribute("value", value);
}
}
| 19.875
| 74
| 0.640252
|
60abc4e2b6e35a6b2abfd8123b9de2d6e2f7ef0f
| 4,775
|
/*
* Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0, which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package com.sun.xml.ws.api.server;
import com.sun.istack.Nullable;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.stream.XMLStreamException;
import javax.xml.namespace.QName;
import java.io.OutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Set;
import org.glassfish.gmbal.ManagedAttribute;
import org.glassfish.gmbal.ManagedData;
/**
* Represents an individual document that forms a {@link ServiceDefinition}.
*
* <pre>
* TODO:
* how does those documents refer to each other?
*
* </pre>
*
* @author Jitendra Kotamraju
*/
@ManagedData
public interface SDDocument {
/**
* Gets the root tag name of this document.
*
* <p>
* This can be used to identify a kind of document quickly
* (such as schema, WSDL, ...)
*
* @return
* always non-null.
*/
@ManagedAttribute
QName getRootName();
/**
* Returns true if this document is WSDL.
*/
@ManagedAttribute
boolean isWSDL();
/**
* Returns true if this document is schema.
*/
@ManagedAttribute
boolean isSchema();
/**
* returns the referenced documents
*/
@ManagedAttribute
Set<String> getImports();
/**
* Gets the system ID of the document where it's taken from. Generated documents
* use a fake URL that can be used to resolve relative URLs. So donot use this URL
* for reading or writing.
*/
@ManagedAttribute
URL getURL();
/**
* Writes the document to the given {@link OutputStream}.
*
* <p>
* Since {@link ServiceDefinition} doesn't know which endpoint address
* {@link Adapter} is serving to, (and often it serves multiple URLs
* simultaneously), this method takes the PortAddressResolver as a parameter,
* so that it can produce the corret address information in the generated WSDL.
*
* @param portAddressResolver
* An endpoint address resolver that gives endpoint address for a WSDL
* port. Can be null.
* @param resolver
* Used to resolve relative references among documents.
* @param os
* The {@link OutputStream} that receives the generated document.
*
* @throws IOException
* if there was a failure reported from the {@link OutputStream}.
*/
void writeTo(@Nullable PortAddressResolver portAddressResolver,
DocumentAddressResolver resolver, OutputStream os) throws IOException;
/**
* Writes the document to the given {@link XMLStreamWriter}.
*
* <p>
* The same as {@link #writeTo(PortAddressResolver,DocumentAddressResolver,OutputStream)} except
* it writes to an {@link XMLStreamWriter}.
*
* <p>
* The implementation must not call {@link XMLStreamWriter#writeStartDocument()}
* nor {@link XMLStreamWriter#writeEndDocument()}. Those are the caller's
* responsibility.
*
* @throws XMLStreamException
* if the {@link XMLStreamWriter} reports an error.
*/
void writeTo(PortAddressResolver portAddressResolver,
DocumentAddressResolver resolver, XMLStreamWriter out) throws XMLStreamException, IOException;
/**
* {@link SDDocument} that represents an XML Schema.
*/
interface Schema extends SDDocument {
/**
* Gets the target namepsace of this schema.
*/
@ManagedAttribute
String getTargetNamespace();
}
/**
* {@link SDDocument} that represents a WSDL.
*/
interface WSDL extends SDDocument {
/**
* Gets the target namepsace of this schema.
*/
@ManagedAttribute
String getTargetNamespace();
/**
* This WSDL has a portType definition
* that matches what {@link WSEndpoint} is serving.
*
* TODO: does this info needs to be exposed?
*/
@ManagedAttribute
boolean hasPortType();
/**
* This WSDL has a service definition
* that matches the {@link WSEndpoint}.
*
* TODO: does this info need to be exposed?
*/
@ManagedAttribute
boolean hasService();
/**
* All <service> names that were in this WSDL, or empty set if there was none.
* Used for error diagnostics.
*/
@ManagedAttribute
Set<QName> getAllServices();
}
}
| 28.76506
| 106
| 0.636649
|
96cc4888f2c8bd3f7066cb0a9724738604159bde
| 5,754
|
/*
* Copyright (c) 2018 YCSB contributors. All rights reserved.
* <p>
* 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
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* 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. See accompanying
* LICENSE file.
*/
package com.yahoo.ycsb.generator.graph;
import org.apache.commons.io.FileUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class TestGraphDataGenerator {
private static File testDirectory;
private static Properties properties;
private static int numberOfNodes;
@BeforeClass
public static void setUp() {
testDirectory = new File(System.getProperty("user.dir"), "test");
properties = new Properties();
properties.setProperty("testparametercount", "1");
numberOfNodes = 1000;
}
@AfterClass
public static void deleteDirectory() throws IOException {
FileUtils.deleteDirectory(testDirectory);
}
@After
public void clearDirectory() throws IOException {
FileUtils.deleteDirectory(testDirectory);
}
@Test
public void testLoadPhase() throws IOException {
GraphDataGenerator recorder = GraphDataGenerator.create(testDirectory.getAbsolutePath(), false, properties);
assertTrue(recorder instanceof GraphDataRecorder);
ArrayList<Graph> graphs = new ArrayList<>();
for (int i = 0; i < numberOfNodes; i++) {
graphs.add(recorder.nextValue());
}
GraphDataGenerator recreator = GraphDataRecreator.create(testDirectory.getAbsolutePath(), false, properties);
assertTrue(recreator instanceof GraphDataRecreator);
compareRecreatedGraphs(graphs, recreator);
}
@Test
public void testRunPhase() throws IOException {
GraphDataGenerator recorder = GraphDataGenerator.create(testDirectory.getAbsolutePath(), true, properties);
assertTrue(recorder instanceof GraphDataRecorder);
ArrayList<Graph> graphs = new ArrayList<>();
for (int i = 0; i < numberOfNodes; i++) {
graphs.add(recorder.nextValue());
}
GraphDataGenerator recreator = GraphDataRecreator.create(testDirectory.getAbsolutePath(), true, properties);
assertTrue(recreator instanceof GraphDataRecreator);
compareRecreatedGraphs(graphs, recreator);
}
@Test
public void testRunPhaseWithLoadData() throws IOException, NoSuchFieldException, IllegalAccessException {
GraphDataGenerator recorder = GraphDataGenerator.create(testDirectory.getAbsolutePath(), false, properties);
assertTrue(recorder instanceof GraphDataRecorder);
for (int i = 0; i < numberOfNodes; i++) {
recorder.nextValue();
}
resetStaticFieldsOfNodeAndEdge();
recorder = GraphDataGenerator.create(testDirectory.getAbsolutePath(), true, properties);
assertTrue(recorder instanceof GraphDataRecorder);
ArrayList<Graph> graphs = new ArrayList<>();
for (int i = 0; i < numberOfNodes; i++) {
graphs.add(recorder.nextValue());
}
GraphDataGenerator recreator = GraphDataGenerator.create(testDirectory.getAbsolutePath(), true, properties);
assertTrue(recreator instanceof GraphDataRecreator);
compareRecreatedGraphs(graphs, recreator);
}
public static void resetStaticFieldsOfNodeAndEdge() throws NoSuchFieldException, IllegalAccessException {
Field field = Node.class.getDeclaredField("nodeIdCount");
field.setAccessible(true);
field.set(null, 0L);
field.setAccessible(false);
field = Edge.class.getDeclaredField("edgeIdCount");
field.setAccessible(true);
field.set(null, 0L);
field.setAccessible(false);
}
private void compareRecreatedGraphs(ArrayList<Graph> graphs, GraphDataGenerator recreator) {
for (Graph originalGraph : graphs) {
Graph recreatedGraph = recreator.nextValue();
assertEquals(originalGraph.getNodes().size(), recreatedGraph.getNodes().size());
assertEquals(originalGraph.getEdges().size(), recreatedGraph.getEdges().size());
List<Node> originalNodes = originalGraph.getNodes();
List<Node> recreatedNodes = recreatedGraph.getNodes();
for (int i = 0; i < originalNodes.size(); i++) {
Node originalNode = originalNodes.get(i);
Node recreatedNode = recreatedNodes.get(i);
assertEquals(originalNode.getId(), recreatedNode.getId());
assertEquals(originalNode.getLabel(), recreatedNode.getLabel());
assertEquals(originalNode.getHashMap().toString(), recreatedNode.getHashMap().toString());
}
List<Edge> originalEdges = originalGraph.getEdges();
List<Edge> recreatedEdges = recreatedGraph.getEdges();
for (int i = 0; i < originalEdges.size(); i++) {
Edge originalEdge = originalEdges.get(i);
Edge recreatedEdge = recreatedEdges.get(i);
assertEquals(originalEdge.getId(), recreatedEdge.getId());
assertEquals(originalEdge.getLabel(), recreatedEdge.getLabel());
assertEquals(originalEdge.getStartNodeId(), recreatedEdge.getStartNodeId());
assertEquals(originalEdge.getEndNodeId(), recreatedEdge.getEndNodeId());
}
}
}
}
| 33.260116
| 113
| 0.730275
|
e016abc8de638fe4290db386c7fcaa47c1b3646e
| 817
|
package extracells.api.definitions;
public interface IPartDefinition {
appeng.api.definitions.IItemDefinition partConversionMonitor();
appeng.api.definitions.IItemDefinition partFluidAnnihilationPlane();
appeng.api.definitions.IItemDefinition partFluidExportBus();
appeng.api.definitions.IItemDefinition partFluidFormationPlane();
appeng.api.definitions.IItemDefinition partFluidImportBus();
appeng.api.definitions.IItemDefinition partFluidLevelEmitter();
appeng.api.definitions.IItemDefinition partFluidStorageBus();
appeng.api.definitions.IItemDefinition partFluidTerminal();
appeng.api.definitions.IItemDefinition partInterface();
appeng.api.definitions.IItemDefinition partOreDictExportBus();
appeng.api.definitions.IItemDefinition partStorageMonitor();
}
| 29.178571
| 72
| 0.807834
|
e72a5406ebcade90ed0678334c5f49bbd20fa2e1
| 15,480
|
package fun.epoch.mall.service;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import fun.epoch.mall.common.Constant;
import fun.epoch.mall.common.Constant.OrderStatus;
import fun.epoch.mall.dao.*;
import fun.epoch.mall.entity.*;
import fun.epoch.mall.exception.OrderCreateException;
import fun.epoch.mall.exception.OrderUpdateException;
import fun.epoch.mall.service.pay.AlipayService;
import fun.epoch.mall.utils.DateTimeUtils;
import fun.epoch.mall.utils.PageUtils;
import fun.epoch.mall.utils.TextUtils;
import fun.epoch.mall.utils.response.ServerResponse;
import fun.epoch.mall.vo.OrderVo;
import fun.epoch.mall.vo.ProductVo;
import fun.epoch.mall.vo.QrCodeVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import static fun.epoch.mall.common.Constant.OrderStatus.valueOf;
import static fun.epoch.mall.common.Constant.OrderStatus.*;
import static fun.epoch.mall.common.Constant.PaymentPlatform.ALIPAY;
import static fun.epoch.mall.common.Constant.PaymentType.ONLINE_PAY;
import static fun.epoch.mall.common.Constant.SaleStatus.OFF_SALE;
import static fun.epoch.mall.utils.response.ResponseCode.*;
@Service
public class OrderService {
String imageHost = Constant.settings.get(Constant.SettingKeys.IMAGE_HOST);
@Autowired
OrderMapper orderMapper;
@Autowired
ShippingMapper shippingMapper;
@Autowired
OrderItemMapper orderItemMapper;
@Autowired
CartItemMapper cartItemMapper;
@Autowired
ProductMapper productMapper;
@Autowired
AlipayService alipayService;
public ServerResponse<OrderVo> detail(long orderNo) {
return detail(orderMapper.selectByOrderNo(orderNo), null);
}
public ServerResponse<OrderVo> detail(int userId, long orderNo) {
return detail(orderMapper.selectByOrderNo(orderNo), userId);
}
public ServerResponse<PageInfo<OrderVo>> search(Long orderNo, Integer userId, String keyword, Integer status, Long startTime, Long endTime, int pageNum, int pageSize) {
PageInfo<Order> page = PageHelper.startPage(pageNum, pageSize).doSelectPageInfo(
() -> orderMapper.search(orderNo, userId, keyword, status, startTime, endTime)
);
List<OrderVo> orderVos = page.getList().stream().map(this::toOrderVo).collect(Collectors.toList());
return ServerResponse.success(PageUtils.convert(page, orderVos));
}
public ServerResponse ship(long orderNo) {
return updateOrderStatus(orderNo, SHIPPED.getCode(), CANCELED, UNPAID, OrderStatus.SUCCESS, CLOSED);
}
@Transactional
public ServerResponse close(long orderNo) {
ServerResponse updateOrderStatus = updateOrderStatus(orderNo, CLOSED.getCode(), CANCELED, PAID, SHIPPED, OrderStatus.SUCCESS);
if (updateOrderStatus.isSuccess()) {
try {
restoreProductStock(orderNo);
} catch (OrderUpdateException e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return ServerResponse.error(INTERNAL_SERVER_ERROR, e.getMessage());
}
}
return updateOrderStatus;
}
public ServerResponse<OrderVo> preview(int userId) {
ServerResponse<List<OrderItem>> generateOrderItems = generateOrderItems(userId, null);
if (generateOrderItems.isError()) return ServerResponse.response(generateOrderItems);
List<OrderItem> orderItems = generateOrderItems.getData();
OrderVo orderVo = OrderVo.builder()
.payment(countPayment(orderItems))
.postage(new BigDecimal("0"))
.products(orderItems)
.build();
return ServerResponse.success(orderVo);
}
public ServerResponse<OrderVo> create(int userId, int shippingId) {
ServerResponse<OrderVo> checkShipping = checkShipping(userId, shippingId);
if (checkShipping.isError()) return checkShipping;
long orderNo = newOrderNo();
ServerResponse<List<OrderItem>> generateOrderItems = generateOrderItems(userId, orderNo);
if (generateOrderItems.isError()) return ServerResponse.response(generateOrderItems);
List<OrderItem> orderItems = generateOrderItems.getData();
Order order = Order.builder()
.userId(userId)
.shippingId(shippingId)
.orderNo(orderNo)
.payment(countPayment(orderItems))
.postage(new BigDecimal("0"))
.status(UNPAID.getCode())
.paymentType(ONLINE_PAY.getCode())
.build();
return createOrder(order, orderItems);
}
@Transactional
public ServerResponse cancel(int userId, long orderNo) {
Order order = orderMapper.selectByOrderNo(orderNo);
if (order == null) {
return ServerResponse.error(NOT_FOUND, "找不到订单");
}
if (order.getUserId() != userId) {
return ServerResponse.error(FORBIDDEN, "无权限，该订单不属于当前用户");
}
ServerResponse updateOrderStatus = updateOrderStatus(orderNo, CANCELED.getCode(), SHIPPED, OrderStatus.SUCCESS, CLOSED);
if (updateOrderStatus.isSuccess()) {
try {
restoreProductStock(orderNo);
} catch (OrderUpdateException e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return ServerResponse.error(INTERNAL_SERVER_ERROR, e.getMessage());
}
}
return updateOrderStatus;
}
public ServerResponse<QrCodeVo> pay(int userId, long orderNo, int paymentType, int paymentPlatform) {
Order order = orderMapper.selectByOrderNo(orderNo);
if (order == null) {
return ServerResponse.error(NOT_FOUND, "找不到订单");
}
if (order.getUserId() != userId) {
return ServerResponse.error(FORBIDDEN, "无权限，该订单不属于当前用户");
}
if (order.getStatus() != UNPAID.getCode()) {
return ServerResponse.error("订单已支付");
}
PaymentService paymentService = choosePaymentService(paymentType, paymentPlatform);
return paymentService.preOrder(toOrderVo(order));
}
private PaymentService choosePaymentService(int paymentType, int paymentPlatform) {
if (paymentType == ONLINE_PAY.getCode() && paymentPlatform == ALIPAY.getCode()) {
return alipayService;
}
return alipayService;
}
public ServerResponse<Boolean> queryPaymentStatus(int userId, long orderNo) {
Order order = orderMapper.selectByOrderNo(orderNo);
if (order == null) {
return ServerResponse.error(NOT_FOUND, "找不到订单");
}
if (order.getUserId() != userId) {
return ServerResponse.error(FORBIDDEN, "无权限，该订单不属于当前用户");
}
return ServerResponse.success(order.getStatus() != UNPAID.getCode());
}
/* ****************************** 查询订单 开始 ****************************** */
private ServerResponse<OrderVo> detail(Order order, Integer userId) {
if (order == null) return ServerResponse.error(NOT_FOUND, "找不到订单");
if (userId != null && !userId.equals(order.getUserId())) return ServerResponse.error(FORBIDDEN, "无权限，该订单不属于当前用户");
return ServerResponse.success(toOrderVo(order));
}
OrderVo toOrderVo(Order order) {
Shipping shipping = shippingMapper.selectByPrimaryKey(order.getShippingId());
List<OrderItem> products = orderItemMapper.selectByOrderNo(order.getOrderNo());
return toOrderVo(order, shipping, products);
}
private OrderVo toOrderVo(Order order, Shipping shipping, List<OrderItem> products) {
return OrderVo.builder()
.orderNo(order.getOrderNo())
.userId(order.getUserId())
.shipping(shipping)
.products(products)
.payment(order.getPayment())
.postage(order.getPostage())
.paymentType(order.getPaymentType())
.paymentTypeDesc(Constant.PaymentType.valueOf(order.getPaymentType()))
.status(order.getStatus())
.statusDesc(OrderStatus.valueOf(order.getStatus()))
.createTime(DateTimeUtils.format(order.getCreateTime()))
.paymentTime(DateTimeUtils.format(order.getPaymentTime()))
.shipTime(DateTimeUtils.format(order.getSendTime()))
.endTime(DateTimeUtils.format(order.getEndTime()))
.closeTime(DateTimeUtils.format(order.getCloseTime()))
.build();
}
/* ****************************** 更新订单 开始 ****************************** */
private ServerResponse updateOrderStatus(long orderNo, int expectedStatus, OrderStatus... unexpectedStatus) {
Order order = orderMapper.selectByOrderNo(orderNo);
if (order == null) return ServerResponse.error(NOT_FOUND, "找不到订单");
if (unexpectedStatus != null && unexpectedStatus.length > 0) {
for (OrderStatus status : unexpectedStatus) {
if (status.getCode() == order.getStatus()) {
String errorMsg = String.format("订单状态变更失败：[%s] --> [%s], 订单状态不合适", valueOf(order.getStatus()), valueOf(expectedStatus));
return ServerResponse.error(errorMsg);
}
}
}
order.setStatus(expectedStatus);
if (orderMapper.updateSelectiveByPrimaryKey(order) == 0) {
String errorMsg = String.format("订单状态变更失败：[%s] --> [%s]", valueOf(order.getStatus()), valueOf(expectedStatus));
return ServerResponse.error(INTERNAL_SERVER_ERROR, errorMsg);
}
return ServerResponse.success();
}
void restoreProductStock(long orderNo) {
OrderVo orderVo = detail(orderNo).getData();
orderVo.getProducts().forEach(item -> {
Product product = productMapper.selectByPrimaryKey(item.getProductId());
if (product != null) {
product.setStock(product.getStock() + item.getQuantity());
if (productMapper.updateSelectiveByPrimaryKey(product) != 1) {
throw new OrderUpdateException(String.format("恢复商品[%s]库存失败", product.getId()));
}
}
});
}
/* ****************************** 预览订单 开始 ****************************** */
private ServerResponse<List<OrderItem>> generateOrderItems(int userId, Long orderNo) {
List<CartItem> cartItems = cartItemMapper.selectCheckedItemsByUserId(userId);
if (cartItems == null || cartItems.size() == 0) {
return ServerResponse.error("购物车中没有选中的商品");
}
List<OrderItem> orderItems = new ArrayList<>();
for (CartItem cartItem : cartItems) {
Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
ServerResponse<List<OrderItem>> checkProduct = checkProduct(cartItem, product);
if (checkProduct.isError()) return checkProduct;
orderItems.add(toOrderItem(orderNo, product, cartItem.getQuantity()));
}
return ServerResponse.success(orderItems);
}
private ServerResponse<List<OrderItem>> checkProduct(CartItem cartItem, Product product) {
if (product == null) {
return ServerResponse.error(NOT_FOUND, String.format("商品 [%s] 不存在", cartItem.getProductId()));
}
if (product.getStatus() == OFF_SALE) {
return ServerResponse.error(NOT_FOUND, String.format("商品 [%s] 已下架", product.getId()));
}
if (product.getStock() < cartItem.getQuantity()) {
return ServerResponse.error(String.format("商品 [%s] 数量超过限制：库存不足", product.getId()));
}
return ServerResponse.success();
}
private OrderItem toOrderItem(Long orderNo, Product product, int quantity) {
BigDecimal totalPrice = product.getPrice().multiply(new BigDecimal(quantity));
String mainImage = ProductVo.extractMainImage(product);
String productImage = TextUtils.isNotBlank(mainImage) ? imageHost + mainImage : "";
return OrderItem.builder()
.orderNo(orderNo)
.productId(product.getId())
.productName(product.getName())
.unitPrice(product.getPrice())
.totalPrice(totalPrice)
.quantity(quantity)
.productImage(productImage)
.build();
}
/* ****************************** 创建订单 开始 ****************************** */
private ServerResponse<OrderVo> checkShipping(int userId, int shippingId) {
Shipping shipping = shippingMapper.selectByPrimaryKey(shippingId);
if (shipping == null) {
return ServerResponse.error(NOT_FOUND, "收货地址不存在");
}
if (shipping.getUserId() != userId) {
return ServerResponse.error(FORBIDDEN, "无权限，收货地址不属于当前用户");
}
return ServerResponse.success();
}
private BigDecimal countPayment(List<OrderItem> orderItems) {
return orderItems.stream().map(OrderItem::getTotalPrice).reduce(BigDecimal::add).orElse(new BigDecimal("0"));
}
private long newOrderNo() {
return System.currentTimeMillis() + new Random().nextInt(100) % 10;
}
@Transactional
ServerResponse<OrderVo> createOrder(Order order, List<OrderItem> orderItems) {
try {
this
.insertOrder(order)
.insertOrderItem(orderItems)
.updateProductStock(orderItems)
.cleanCart(order, orderItems);
return detail(order.getOrderNo());
} catch (OrderCreateException e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return ServerResponse.error(INTERNAL_SERVER_ERROR, e.getMessage());
}
}
private OrderService insertOrder(Order order) {
if (orderMapper.insert(order) != 1) {
throw new OrderCreateException("创建订单失败：生成订单失败");
}
return this;
}
private OrderService insertOrderItem(List<OrderItem> orderItems) {
orderItems.forEach(orderItem -> {
if (orderItemMapper.insert(orderItem) != 1) {
throw new OrderCreateException("创建订单失败：生成订单明细失败");
}
});
return this;
}
private OrderService updateProductStock(List<OrderItem> orderItems) {
for (OrderItem item : orderItems) {
Product product = productMapper.selectByPrimaryKey(item.getProductId());
product.setStock(product.getStock() - item.getQuantity());
if (productMapper.updateSelectiveByPrimaryKey(product) != 1) {
throw new OrderCreateException("创建订单失败：更新商品库存失败");
}
}
return this;
}
private OrderService cleanCart(Order order, List<OrderItem> orderItems) {
if (cartItemMapper.deleteCheckedByUserId(order.getUserId()) != orderItems.size()) {
throw new OrderCreateException("创建订单失败：清空购物车商品失败");
}
return this;
}
}
| 41.28
| 172
| 0.641473
|
c6aef6fcb424833d5377868bc1b52a3940853e9d
| 48,114
|
package com.p4f.esp32camai;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.Handler;
import android.text.InputType;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.Pair;
import android.util.Size;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.FrameLayout;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.widget.Toast;
import androidx.fragment.app.Fragment;
import com.p4f.esp32camai.tflite.Classifier;
import com.p4f.esp32camai.tflite.TFLiteObjectDetectionSSDAPIModel;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import android.graphics.Point;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.opencv.android.OpenCVLoader;
import org.opencv.android.Utils;
import org.opencv.core.CvException;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;
import org.opencv.tracking.Tracker;
import org.opencv.tracking.TrackerCSRT;
import org.opencv.tracking.TrackerKCF;
import org.opencv.tracking.TrackerMIL;
import org.opencv.tracking.TrackerMOSSE;
import org.opencv.tracking.TrackerMedianFlow;
import org.opencv.tracking.TrackerTLD;
public class Esp32CameraFragment extends Fragment{
public enum STATE {
STOP,
RUN,
PAUSE
};
enum Drawing{
DRAWING,
TRACKING,
CLEAR,
}
final String TAG = "ExCameraFragment";
private UDPSocket mUdpClient;
private String mServerAddressBroadCast = "255.255.255.255";
InetAddress mServerAddr;
int mServerPort = 6868;
final byte[] mRequestConnect = new byte[]{'w','h','o','a','m','i'};
final byte[] mRequestForward = new byte[]{'f','o','r','w','a','r','d'};
final byte[] mRequestForwardTrack = new byte[]{'f','w','t','r','a','c','k'};
final byte[] mRequestBackward = new byte[]{'b','a','c','k','w','a','r','d'};
final byte[] mRequestLeft = new byte[]{'l','e','f','t'};
final byte[] mRequestLeftTrack = new byte[]{'l','e','f','t','t','r','a','c','k'};
final byte[] mRequestRight = new byte[]{'r','i','g','h','t'};
final byte[] mRequestRightTrack = new byte[]{'r','i','g','h','t','t','r','a','c','k'};
final byte[] mRequestStop = new byte[]{'s','t','o','p'};
final byte[] mRequestCamUp = new byte[]{'c','a','m','u','p'};
final byte[] mRequestCamDown = new byte[]{'c','a','m','d','o','w','n'};
final byte[] mRequestCamLeft = new byte[]{'c','a','m','l','e','f','t'};
final byte[] mRequestCamRight = new byte[]{'c','a','m','r','i','g','h','t'};
final byte[] mRequestCamStill = new byte[]{'c','a','m','s','t','i','l','l'};
final byte[] mLedOn = new byte[]{'l','e','d','o','n'};
final byte[] mLedOff = new byte[]{'l','e','d','o','f','f'};
private Handler handler = new Handler();
private Bitmap mBitmap;
ImageView mServerImageView;
Handler mHandler = new Handler();
private WebSocketClient mWebSocketClient;
private String mServerExactAddress;
private boolean mInitStream = false;
private boolean mInitTrackObj = false;
private boolean mStream = false;
private boolean mObjDet = false;
private boolean mLed = false;
ImageButton mBackMoveBtn;
ImageButton mForMoveBtn;
ImageButton mRightMoveBtn;
ImageButton mLeftMoveBtn;
private Classifier detectorSSD;
private List<TFLiteObjectDetectionSSDAPIModel.Recognition> detectorSSDResult = new ArrayList<>();
private final Size CamResolution = new Size(640, 480);
private OverlayView mTrackingOverlay;
private Bitmap mBitmapDebug;
private boolean mProcessing = false;
private Point[] mPoints = new Point[4];
private Point mPointCircle = new Point();
private int mRadiusCircle = 0;
private Drawing mDrawing = Drawing.CLEAR;
private boolean mTargetLocked = false;
private Bitmap mBitmapGrab = null;
private String mSelectedTracker = "None";
private String mSelectedTrackerPre = "None";
private Tracker mTracker;
private Mat mMatGrabInit;
private Mat mMatGrab;
private org.opencv.core.Rect2d mInitRectangle = null;
private int mBinaryThreshold = 80;
private int mRadioIndex = 0;
private Bitmap mBitmapLaneTracking = null;
// final String[] mRadioBtnNames = {
// "None",
// "TrackerMedianFlow",
// "TrackerCSRT",
// "TrackerKCF",
// "TrackerMOSSE",
// "TrackerTLD",
// "TrackerMIL",
// "LaneTracking"
// };
final String[] mRadioBtnNames = {
"None",
"ObjectTracking",
"LaneTracking"
};
public void onWindowFocusChanged(){
int testW = mTrackingOverlay.getWidth();
int testH = mTrackingOverlay.getHeight();
// mTrackingOverlay.setLayoutParams(new FrameLayout.LayoutParams(testW, CamResolution.getWidth()/CamResolution.getHeight()*testW));
// mServerImageView.setLayoutParams(new FrameLayout.LayoutParams(testW, CamResolution.getWidth()/CamResolution.getHeight()*testW));
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mUdpClient = new UDPSocket(12345);
mUdpClient.runUdpServer();
try {
mServerAddr = InetAddress.getByName(mServerAddressBroadCast);
}catch (Exception e){
}
AssetManager assetManager = getActivity().getAssets();
if (MyConstants.DEBUG) {
try {
InputStream istr = assetManager.open("image1.jpg");
Bitmap tmpBitmap = BitmapFactory.decodeStream(istr);
mBitmapDebug = Bitmap.createScaledBitmap(tmpBitmap, CamResolution.getWidth(), CamResolution.getHeight(), false);
} catch (IOException e) {
// handle exception
}
}
if (!OpenCVLoader.initDebug()) {
Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_4_0, getActivity(), null);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup parent, Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_camera, parent, false);
mServerImageView = (ImageView)rootView.findViewById(R.id.imageView);
Button streamBtn = (Button) rootView.findViewById(R.id.streamBtn);
streamBtn.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
if (!mStream) {
try {
mServerAddr = InetAddress.getByName(mServerAddressBroadCast);
}catch (Exception e){
}
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestConnect);
Pair<SocketAddress, String> res = mUdpClient.getResponse();
int cnt = 3;
while (res.first == null && cnt > 0) {
res = mUdpClient.getResponse();
cnt--;
}
if (res.first != null) {
Log.d(TAG, res.first.toString() + ":" + res.second);
mServerExactAddress = res.first.toString().split(":")[0].replace("/","");
mStream = true;
connectWebSocket();
((Button) getActivity().findViewById(R.id.streamBtn)).setBackgroundResource(R.drawable.my_button_bg_2);
((Button) getActivity().findViewById(R.id.streamBtn)).setTextColor(Color.rgb(0,0,255));
try {
mServerAddr = InetAddress.getByName(mServerExactAddress);
}catch (Exception e){
}
}else{
Toast toast =
Toast.makeText(
getActivity(), "Cannot connect to ESP32 Camera", Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
} else {
mStream = false;
mWebSocketClient.close();
((Button) getActivity().findViewById(R.id.streamBtn)).setBackgroundResource(R.drawable.my_button_bg);
((Button) getActivity().findViewById(R.id.streamBtn)).setTextColor(Color.rgb(255,255,255));
}
}
});
Button ledBtn = (Button) rootView.findViewById(R.id.ledBtn);
ledBtn.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
if (!mLed) {
mLed = true;
((Button) getActivity().findViewById(R.id.ledBtn)).setBackgroundResource(R.drawable.my_button_bg_2);
((Button) getActivity().findViewById(R.id.ledBtn)).setTextColor(Color.rgb(0,0,255));
mUdpClient.sendBytes(mServerAddr, mServerPort, mLedOn);
}else{
mLed = false;
((Button) getActivity().findViewById(R.id.ledBtn)).setBackgroundResource(R.drawable.my_button_bg);
((Button) getActivity().findViewById(R.id.ledBtn)).setTextColor(Color.rgb(255,255,255));
mUdpClient.sendBytes(mServerAddr, mServerPort, mLedOff);
}
}
});
Button objFollowBtn = (Button) rootView.findViewById(R.id.objTrackBtn);
objFollowBtn.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
if(mTargetLocked==true){
Toast toast =
Toast.makeText(
getActivity(), "Please touch with 2 fingers to release the tracking object first !", Toast.LENGTH_SHORT);
toast.show();
return;
}
trackingDlg();
}
});
Button objDetBtn = (Button) rootView.findViewById(R.id.objDetBtn);
objDetBtn.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
if (!mObjDet) {
((Button) getActivity().findViewById(R.id.objDetBtn)).setBackgroundResource(R.drawable.my_button_bg_2);
((Button) getActivity().findViewById(R.id.objDetBtn)).setTextColor(Color.rgb(0,0,255));
} else {
((Button) getActivity().findViewById(R.id.objDetBtn)).setBackgroundResource(R.drawable.my_button_bg);
((Button) getActivity().findViewById(R.id.objDetBtn)).setTextColor(Color.rgb(255,255,255));
}
mObjDet = !mObjDet;
}
});
ImageButton.OnTouchListener listener = new ImageButton.OnTouchListener() {
@Override
public boolean onTouch(View arg0, MotionEvent event){
if(event.getAction() == MotionEvent.ACTION_DOWN) {
if (((ImageButton) arg0).getId() == R.id.forwardMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_forward_on);
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestForward);
} else if (((ImageButton) arg0).getId() == R.id.backwardMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_backward_on);
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestBackward);
} else if (((ImageButton) arg0).getId() == R.id.leftMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_left_on);
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestLeft);
} else if (((ImageButton) arg0).getId() == R.id.rightMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_right_on);
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestRight);
}
return true;
}else if(event.getAction() == MotionEvent.ACTION_UP) {
if (((ImageButton) arg0).getId() == R.id.forwardMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_forward_off);
} else if (((ImageButton) arg0).getId() == R.id.backwardMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_backward_off);
} else if (((ImageButton) arg0).getId() == R.id.leftMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_left_off);
} else if (((ImageButton) arg0).getId() == R.id.rightMoveBtn) {
((ImageButton)arg0).setImageResource(R.drawable.ic_btn_right_off);
}
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestStop);
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestStop);
return true;
}
return false;
}
};
mBackMoveBtn = (ImageButton)rootView.findViewById(R.id.backwardMoveBtn);
mBackMoveBtn.setOnTouchListener(listener);
mForMoveBtn = (ImageButton)rootView.findViewById(R.id.forwardMoveBtn);
mForMoveBtn.setOnTouchListener(listener);
mRightMoveBtn = (ImageButton)rootView.findViewById(R.id.rightMoveBtn);
mRightMoveBtn.setOnTouchListener(listener);
mLeftMoveBtn = (ImageButton)rootView.findViewById(R.id.leftMoveBtn);
mLeftMoveBtn.setOnTouchListener(listener);
try {
detectorSSD =
TFLiteObjectDetectionSSDAPIModel.create(
getActivity().getAssets(),
"ssdlite_mobilenet_v2_quantized.tflite",
"",
300,
Classifier.Device.CPU,
MyConstants.MODEL_TYPE.UINT8,
0.5f,
1,
CamResolution.getWidth(),
CamResolution.getHeight()
);
detectorSSD.startThread();
} catch (final IOException e) {
Log.e(TAG, "Exception initializing classifier!");
Toast toast =
Toast.makeText(
getActivity(), "Classifier could not be initialized", Toast.LENGTH_SHORT);
toast.show();
}
for (int i=0; i<mPoints.length;i++){
mPoints[i] = new Point(0,0);
}
mTrackingOverlay = (OverlayView) rootView.findViewById(R.id.tracking_overlay);
assert (mTrackingOverlay != null);
mTrackingOverlay.addCallback(
new OverlayView.DrawCallback() {
@Override
public void drawCallback(Canvas canvas) {
if (MyConstants.DEBUG) {
Rect dstRectForRender = new Rect(0, 0, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight());
Matrix matrix = new Matrix();
matrix.postRotate(90);
Bitmap scaleBitmap = Bitmap.createScaledBitmap(mBitmapDebug, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight(), false);
Bitmap rotatedBitmap = Bitmap.createBitmap(scaleBitmap, 0, 0, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight(), matrix, true);
canvas.drawBitmap(rotatedBitmap, null, dstRectForRender, null);
}
if (detectorSSD != null && mObjDet) {
int overlayWidth = mTrackingOverlay.getWidth();
int overlayHeight = mTrackingOverlay.getHeight();
int imgWidth = mBitmapGrab.getWidth();
int imgHeight = mBitmapGrab.getHeight();
((TFLiteObjectDetectionSSDAPIModel) detectorSSD).getResult(detectorSSDResult);
Paint paint = new Paint();
Paint paintText = new Paint();
paint.setColor(Color.rgb(0, 255, 0));
Log.d(TAG, "Obj cnt: " + detectorSSDResult.size());
for (TFLiteObjectDetectionSSDAPIModel.Recognition det : detectorSSDResult) {
Log.d(TAG, "processing: " + det);
paint.setStrokeWidth(10);
paint.setStyle(Paint.Style.STROKE);
float left = det.getLocation().left * mTrackingOverlay.getWidth();
if (left < 0) {
left = 0;
} else if (left > mTrackingOverlay.getWidth()) {
left = mTrackingOverlay.getWidth();
}
float top = det.getLocation().top * mTrackingOverlay.getHeight();
if (top < 0) {
top = 0;
} else if (top > mTrackingOverlay.getHeight()) {
top = mTrackingOverlay.getHeight();
}
float right = det.getLocation().right * mTrackingOverlay.getWidth();
;
if (right < 0) {
right = 0;
} else if (right > mTrackingOverlay.getWidth()) {
right = mTrackingOverlay.getWidth();
}
float bottom = det.getLocation().bottom * mTrackingOverlay.getHeight();
if (bottom < 0) {
bottom = 0;
} else if (bottom > mTrackingOverlay.getHeight()) {
bottom = mTrackingOverlay.getHeight();
}
paintText.setColor(Color.BLUE);
paintText.setStrokeWidth(2);
paintText.setStyle(Paint.Style.FILL);
paintText.setTextSize(50);
canvas.drawRect(left, top, right, bottom, paint);
paint.setStyle(Paint.Style.FILL);
String txt = det.getTitle();// + "(" + String.format("%.2f", det.getConfidence()) + ")";
canvas.drawRect(left, top, left-60, top+txt.length()*30+50, paint);
canvas.save();
canvas.rotate(90, left-50, top + 50);
canvas.drawText(txt, left - 50, top + 50, paintText);
canvas.restore();
}
}
if(mSelectedTracker.equals("ObjectTracking") && mStream){
if(!mInitTrackObj){
String msg1 = "Object is selected by 1 touch and drag following by a";
String msg2 = "rectangle, make double touch with another finger to lock";
String msg3 = "the object, double touch again to release the tracking object";
Paint paintText = new Paint();
paintText.setColor(Color.YELLOW);
paintText.setStrokeWidth(2);
paintText.setStyle(Paint.Style.FILL);
paintText.setTextSize(mTrackingOverlay.getWidth()/23);
canvas.save();
canvas.rotate(90, mTrackingOverlay.getWidth()*10/12, mTrackingOverlay.getHeight()/8);
canvas.drawText(msg1, mTrackingOverlay.getWidth()*5/6, mTrackingOverlay.getHeight()/8, paintText);
canvas.restore();
canvas.save();
canvas.rotate(90, mTrackingOverlay.getWidth()*9/12, mTrackingOverlay.getHeight()/8);
canvas.drawText(msg2, mTrackingOverlay.getWidth()*9/12, mTrackingOverlay.getHeight()/8, paintText);
canvas.restore();
canvas.save();
canvas.rotate(90, mTrackingOverlay.getWidth()*8/12, mTrackingOverlay.getHeight()/8);
canvas.drawText(msg3, mTrackingOverlay.getWidth()*8/12, mTrackingOverlay.getHeight()/8, paintText);
canvas.restore();
canvas.save();
}
if(mDrawing != Drawing.CLEAR) {
Paint paint = new Paint();
paint.setColor(Color.rgb(0, 0, 255));
paint.setStrokeWidth(10);
paint.setStyle(Paint.Style.STROKE);
canvas.drawRect(mPoints[0].x, mPoints[0].y, mPoints[1].x, mPoints[1].y, paint);
if (mDrawing == Drawing.TRACKING) {
paint.setColor(Color.rgb(0, 255, 0));
canvas.drawLine((mPoints[0].x + mPoints[1].x) / 2,
0,
(mPoints[0].x + mPoints[1].x) / 2,
mTrackingOverlay.getHeight(),
paint);
canvas.drawLine(0,
(mPoints[0].y + mPoints[1].y) / 2,
mTrackingOverlay.getWidth(),
(mPoints[0].y + mPoints[1].y) / 2,
paint);
paint.setColor(Color.YELLOW);
paint.setStrokeWidth(2);
paint.setStyle(Paint.Style.FILL);
paint.setTextSize(30);
String strX = Integer.toString((mPoints[0].x + mPoints[1].x) / 2) + "/" + Integer.toString(mTrackingOverlay.getWidth());
String strY = Integer.toString((mPoints[0].y + mPoints[1].y) / 2) + "/" + Integer.toString(mTrackingOverlay.getHeight());
canvas.drawText(strX, (mPoints[0].x + mPoints[1].x) / 4, (mPoints[0].y + mPoints[1].y) / 2 - 10, paint);
canvas.save();
canvas.rotate(90, (mPoints[0].x + mPoints[1].x) / 2 + 10, (mPoints[0].y + mPoints[1].y) / 4);
canvas.drawText(strY, (mPoints[0].x + mPoints[1].x) / 2 + 10, (mPoints[0].y + mPoints[1].y) / 4, paint);
canvas.restore();
}
}
}else if(mSelectedTracker.equals("LaneTracking") && mStream){
Rect dstRectForRender = new Rect(0, 0, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight());
Matrix matrix = new Matrix();
matrix.postRotate(90);
Bitmap scaleBitmap = Bitmap.createScaledBitmap(mBitmapLaneTracking, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight(), false);
Bitmap rotatedBitmap = Bitmap.createBitmap(scaleBitmap, 0, 0, mTrackingOverlay.getWidth(), mTrackingOverlay.getHeight(), matrix, true);
Paint alphaPaint = new Paint();
alphaPaint.setAlpha(42);
canvas.drawBitmap(rotatedBitmap, null, dstRectForRender, alphaPaint);
}else if(mSelectedTracker.equals("ColorTracking") && mStream){
Paint paint = new Paint();
paint.setColor(Color.argb(50,0, 0, 255));
paint.setStrokeWidth(10);
paint.setStyle(Paint.Style.FILL);
canvas.drawCircle(mPointCircle.x, mPointCircle.y, mRadiusCircle, paint);
}else if(mSelectedTracker.equals("None") && mStream){
mInitTrackObj = false;
//TODO
if(!mInitStream){
Paint paintText = new Paint();
paintText.setColor(Color.YELLOW);
paintText.setStrokeWidth(2);
paintText.setStyle(Paint.Style.FILL);
paintText.setTextSize(mTrackingOverlay.getWidth()/20);
canvas.save();
canvas.rotate(90, mTrackingOverlay.getWidth()*5/6, mTrackingOverlay.getHeight()/8);
canvas.drawText("Touch upper half screen to move camera up !", mTrackingOverlay.getWidth()*5/6, mTrackingOverlay.getHeight()/8, paintText);
canvas.restore();
canvas.save();
canvas.rotate(90, mTrackingOverlay.getWidth()/6, mTrackingOverlay.getHeight()/8);
canvas.drawText("Touch lower half screen to move camera down !", mTrackingOverlay.getWidth()/6, mTrackingOverlay.getHeight()/8, paintText);
canvas.restore();
}
}
}
}
);
mTrackingOverlay.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent event) {
final int X = (int) event.getX();
final int Y = (int) event.getY();
Log.d(TAG, ": " + Integer.toString(X) + " " + Integer.toString(Y) );
mInitStream = true;
mInitTrackObj = true;
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_UP:
// Log.d(TAG, ": " + "MotionEvent.ACTION_UP" );
if (mSelectedTracker.equals("None")) {
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamStill);
break;
}
if(!mTargetLocked) {
mDrawing = Drawing.CLEAR;
mTrackingOverlay.postInvalidate();
}
break;
case MotionEvent.ACTION_POINTER_DOWN:
// Log.d(TAG, ": " + "MotionEvent.ACTION_POINTER_DOWN" );
if(mSelectedTracker.equals("ObjectTracking")==false){
break;
}
if (mTargetLocked == false) {
if((mPoints[0].x-mPoints[1].x != 0) && (mPoints[0].y-mPoints[1].y != 0)) {
mTargetLocked = true;
mMatGrab = new Mat();
Toast toast = Toast.makeText(getActivity(), "Target is LOCKED !", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP | Gravity.CENTER, 0, 0);
toast.show();
}else{
mTargetLocked = false;
}
}else{
mTargetLocked = false;
Toast toast = Toast.makeText(getActivity(), "Target is UNLOCKED !", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP | Gravity.CENTER, 0, 0);
toast.show();
}
mDrawing = Drawing.DRAWING;
mTrackingOverlay.postInvalidate();
break;
case MotionEvent.ACTION_POINTER_UP:
// Log.d(TAG, ": " + "MotionEvent.ACTION_POINTER_UP" );
break;
case MotionEvent.ACTION_DOWN:
// Log.d(TAG, ": " + "MotionEvent.ACTION_DOWN" );
if (mSelectedTracker.equals("None")) {
if (X < mTrackingOverlay.getWidth() / 2) {
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamDown);
} else {
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamUp);
}
break;
}
if(!mTargetLocked && mSelectedTracker.equals("ObjectTracking")) {
mDrawing = Drawing.DRAWING;
mPoints[0].x = X;
mPoints[0].y = Y;
mPoints[1].x = X;
mPoints[1].y = Y;
mTrackingOverlay.postInvalidate();
}
break;
case MotionEvent.ACTION_MOVE:
// Log.d(TAG, ": " + "MotionEvent.ACTION_MOVE" );
if(!mTargetLocked && mSelectedTracker.equals("ObjectTracking")) {
mPoints[1].x = X;
mPoints[1].y = Y;
mTrackingOverlay.postInvalidate();
}
break;
}
// if(mTargetLocked==true){
// getView().findViewById(R.id.objTrackBtn).setEnabled(false);
// }else{
// getView().findViewById(R.id.objTrackBtn).setEnabled(true);
// }
return true;
}
});
return rootView;
}
private void connectWebSocket() {
URI uri;
try {
uri = new URI("ws://"+mServerExactAddress+":86/");
} catch (URISyntaxException e) {
e.printStackTrace();
return;
}
mWebSocketClient = new WebSocketClient(uri) {
@Override
public void onOpen(ServerHandshake serverHandshake) {
Log.d("Websocket", "Open");
}
@Override
public void onClose(int i, String s, boolean b) {
Log.d("Websocket", "Closed " + s);
}
@Override
public void onMessage(String message){
Log.d("Websocket", "Receive");
}
@Override
public void onMessage(ByteBuffer message){
// Log.d("Websocket", "Receive");
getActivity().runOnUiThread(new Runnable() {
@Override
public void run() {
byte[] imageBytes= new byte[message.remaining()];
message.get(imageBytes);
final Bitmap bmp=BitmapFactory.decodeByteArray(imageBytes,0,imageBytes.length);
if (bmp == null)
{
return;
}
int viewWidth = mServerImageView.getWidth();
Matrix matrix = new Matrix();
matrix.postRotate(90);
final Bitmap bmp_traspose = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true );
float imagRatio = (float)bmp_traspose.getHeight()/(float)bmp_traspose.getWidth();
int dispViewH = (int)(viewWidth*imagRatio);
mServerImageView.setImageBitmap(Bitmap.createScaledBitmap(bmp_traspose, viewWidth, dispViewH, false));
mBitmapGrab = bmp;
mProcessing = detectorSSD.IsProcessing;
if (!mProcessing) {
processing();
}
}
});
}
@Override
public void onError(Exception e) {
Log.d("Websocket", "Error " + e.getMessage());
}
};
mWebSocketClient.connect();
}
private void trackingDlg(){
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setTitle("Tracker Selection");
final RadioButton[] rb = new RadioButton[mRadioBtnNames.length];
RadioGroup rg = new RadioGroup(getActivity()); //create the RadioGroup
rg.setOrientation(RadioGroup.VERTICAL);
for(int i=0; i < mRadioBtnNames.length; i++){
rb[i] = new RadioButton(getActivity());
rb[i].setText(" " + mRadioBtnNames[i]);
rb[i].setId(i + 100);
rg.addView(rb[i]);
if(mRadioBtnNames[i].equals(mSelectedTracker)){
rb[i].setChecked(true);
}
}
// This overrides the radiogroup onCheckListener
rg.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener()
{
public void onCheckedChanged(RadioGroup group, int checkedId){
// This will get the radiobutton that has changed in its check state
RadioButton checkedRadioButton = (RadioButton)group.findViewById(checkedId);
// This puts the value (true/false) into the variable
boolean isChecked = checkedRadioButton.isChecked();
if (isChecked)
{
// Changes the textview's text to "Checked: example radiobutton text"
int i = 0;
for( i = 0; i < mRadioBtnNames.length; i++) {
if(checkedRadioButton.getText().toString().replace(" ", "").equals(mRadioBtnNames[i])){
break;
}
}
mRadioIndex = i;
}
}
});
LinearLayout lay = new LinearLayout(getActivity());
lay.setOrientation(LinearLayout.VERTICAL);
lay.setPadding(0,30,0,0);
lay.setGravity(Gravity.CENTER_HORIZONTAL);
lay.addView(rg);
final TextView labelThresh = new TextView(getActivity());
labelThresh.setText("Binary Threshold:");
// Set up the input
final EditText binThresh = new EditText(getActivity());
binThresh.setBackground(null);
// Specify the type of input expected; this, for example, sets the input as a password, and will mask the text
binThresh.setInputType(InputType.TYPE_CLASS_NUMBER);
binThresh.setText(Integer.toString(mBinaryThreshold));
lay.addView(labelThresh);
lay.addView(binThresh);
builder.setView(lay);
// Set up the buttons
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
mSelectedTrackerPre = mSelectedTracker;
mSelectedTracker = mRadioBtnNames[mRadioIndex];
if (!mSelectedTracker.equals("None")) {
((Button) getActivity().findViewById(R.id.objTrackBtn)).setBackgroundResource(R.drawable.my_button_bg_2);
((Button) getActivity().findViewById(R.id.objTrackBtn)).setTextColor(Color.rgb(0,0,255));
} else {
((Button) getActivity().findViewById(R.id.objTrackBtn)).setBackgroundResource(R.drawable.my_button_bg);
((Button) getActivity().findViewById(R.id.objTrackBtn)).setTextColor(Color.rgb(255,255,255));
}
mBinaryThreshold = Integer.parseInt(binThresh.getText().toString());
}
});
builder.setCancelable(false);
Dialog dialog = builder.show();
}
private void processing() {
int overlayWidth = mTrackingOverlay.getWidth();
int overlayHeight = mTrackingOverlay.getHeight();
mRadiusCircle = 0;
if(mObjDet) {
if (MyConstants.DEBUG) {
detectorSSD.setBitmap(mBitmapDebug);
} else {
detectorSSD.setBitmap(mBitmapGrab);
}
}
if(mSelectedTracker.equals("LaneTracking")){
if(mMatGrab==null){
mMatGrab = new Mat();
}
Utils.bitmapToMat(mBitmapGrab, mMatGrab);
org.opencv.imgproc.Imgproc.resize(mMatGrab, mMatGrab, new org.opencv.core.Size(320,240));
Mat gray = new Mat();
Mat binary = new Mat();
org.opencv.imgproc.Imgproc.cvtColor(mMatGrab, gray, Imgproc.COLOR_RGBA2GRAY);
org.opencv.imgproc.Imgproc.threshold( gray, binary, mBinaryThreshold, 255, 0 );
int y = binary.rows()*2/3;
int x0 = -1;
for(int x = 0; x < binary.cols(); ++x){
if(binary.get(y,x)[0] < 125){
x0 = x;
break;
}
}
if(x0 < 0){
mUdpClient.sendBytes(mServerAddr,mServerPort, mRequestForwardTrack);
}else if(x0 < binary.width()/2){
mUdpClient.sendBytes(mServerAddr,mServerPort, mRequestRightTrack);
}else if(x0 > binary.width()/2) {
mUdpClient.sendBytes(mServerAddr,mServerPort, mRequestLeftTrack);
}
//TODO: DEBUG
Mat tmp = new Mat();
try {
Imgproc.cvtColor(binary, tmp, Imgproc.COLOR_GRAY2BGRA);
mBitmapLaneTracking = Bitmap.createBitmap(tmp.cols(), tmp.rows(), Bitmap.Config.ARGB_8888);
Utils.matToBitmap(tmp, mBitmapLaneTracking);
}
catch (CvException e){
Log.d("Exception",e.getMessage());
}
}else if(mSelectedTracker.equals("ColorTracking")){
if(mMatGrab==null){
mMatGrab = new Mat();
}
Utils.bitmapToMat(mBitmapGrab, mMatGrab);
org.opencv.imgproc.Imgproc.resize(mMatGrab, mMatGrab, new org.opencv.core.Size(320,240));
Mat gray = new Mat();
org.opencv.imgproc.Imgproc.cvtColor(mMatGrab, gray, Imgproc.COLOR_RGBA2GRAY);
Mat circles = new Mat();
org.opencv.imgproc.Imgproc.HoughCircles(gray, circles, Imgproc.CV_HOUGH_GRADIENT, 2, gray.rows()/4, 200, 120, 10, 80);
for (int i = 0; i < circles.cols(); i++) {
double[] vCircle = circles.get(0, i);
org.opencv.core.Point pt = new org.opencv.core.Point((int)Math.round(vCircle[0]), (int)Math.round(vCircle[1]));
int radius = (int)Math.round(vCircle[2]);
org.opencv.imgproc.Imgproc.circle(gray, pt, radius, new Scalar(255, 0, 0), 2);
mPointCircle.x = (int)(overlayWidth-pt.y*overlayWidth/gray.rows());
mPointCircle.y = (int)(pt.x*overlayHeight/gray.cols());
mRadiusCircle = radius*overlayWidth/gray.rows();
}
//TODO: DEBUG
Bitmap bmp = null;
Mat tmp = new Mat();
try {
Imgproc.cvtColor(gray, tmp, Imgproc.COLOR_GRAY2BGRA);
bmp = Bitmap.createBitmap(tmp.cols(), tmp.rows(), Bitmap.Config.ARGB_8888);
Utils.matToBitmap(tmp, bmp);
}
catch (CvException e){
Log.d("Exception",e.getMessage());
}
}else if(mTargetLocked && mSelectedTracker.equals("ObjectTracking")) {
Utils.bitmapToMat(mBitmapGrab, mMatGrab);
org.opencv.imgproc.Imgproc.resize(mMatGrab, mMatGrab, new org.opencv.core.Size(320,240));
org.opencv.imgproc.Imgproc.cvtColor(mMatGrab, mMatGrab, Imgproc.COLOR_RGBA2BGR);
if(mDrawing==Drawing.DRAWING) {
int imgWidth = mMatGrab.cols();
int imgHeight = mMatGrab.rows();
int x0 = mPoints[0].y;
int y0 = overlayWidth - mPoints[0].x;
int x1 = mPoints[1].y;
int y1 = overlayWidth - mPoints[1].x;
int minX = (int)((float)Math.min(x0, x1)/overlayHeight*mMatGrab.cols());
int minY = (int)((float)Math.min(y0, y1)/overlayWidth*mMatGrab.rows());
int maxX = (int)((float)Math.max(x0, x1)/overlayHeight*mMatGrab.cols());
int maxY = (int)((float)Math.max(y0, y1)/overlayWidth*mMatGrab.rows());
mInitRectangle = new org.opencv.core.Rect2d(minX, minY, maxX-minX, maxY-minY);
mMatGrabInit = new Mat();
mMatGrab.copyTo(mMatGrabInit);
if(mSelectedTracker.equals("TrackerMedianFlow")) {
mTracker = TrackerMedianFlow.create();
}else if(mSelectedTracker.equals("TrackerCSRT")||mSelectedTracker.equals("ObjectTracking")) {
mTracker = TrackerCSRT.create();
}else if(mSelectedTracker.equals("TrackerKCF")) {
mTracker = TrackerKCF.create();
}else if(mSelectedTracker.equals("TrackerMOSSE")) {
mTracker = TrackerMOSSE.create();
}else if(mSelectedTracker.equals("TrackerTLD")) {
mTracker = TrackerTLD.create();
}else if(mSelectedTracker.equals("TrackerMIL")) {
mTracker = TrackerMIL.create();
}
mTracker.init(mMatGrabInit, mInitRectangle);
mDrawing = Drawing.TRACKING;
//TODO: DEBUG
// org.opencv.core.Rect testRect = new org.opencv.core.Rect(minX, minY, maxX-minX, maxY-minY);
// Mat roi = new Mat(mMatGrab, testRect);
// Bitmap bmp = null;
// Mat tmp = new Mat (roi.rows(), roi.cols(), CvType.CV_8U, new Scalar(4));
// try {
// Imgproc.cvtColor(roi, tmp, Imgproc.COLOR_RGB2BGRA);
// bmp = Bitmap.createBitmap(tmp.cols(), tmp.rows(), Bitmap.Config.ARGB_8888);
// Utils.matToBitmap(tmp, bmp);
// }
// catch (CvException e){
// Log.d("Exception",e.getMessage());
// }
}else{
org.opencv.core.Rect2d trackingRectangle = new org.opencv.core.Rect2d(0, 0, 1,1);
mTracker.update(mMatGrab, trackingRectangle);
// //TODO: DEBUG
// org.opencv.core.Rect testRect = new org.opencv.core.Rect((int)trackingRectangle.x,
// (int)trackingRectangle.y,
// (int)trackingRectangle.width,
// (int)trackingRectangle.height);
// Mat roi = new Mat(mMatGrab, testRect);
// Bitmap bmp = null;
// Mat tmp = new Mat (roi.rows(), roi.cols(), CvType.CV_8U, new Scalar(4));
// try {
// Imgproc.cvtColor(roi, tmp, Imgproc.COLOR_RGB2BGRA);
// bmp = Bitmap.createBitmap(tmp.cols(), tmp.rows(), Bitmap.Config.ARGB_8888);
// Utils.matToBitmap(tmp, bmp);
// }
// catch (CvException e){
// Log.d("Exception",e.getMessage());
// mTargetLocked = false;
// mDrawing = Drawing.DRAWING;
// }
mPoints[1].x = overlayWidth - (int)(trackingRectangle.y*(float)overlayWidth/(float)mMatGrab.rows());
mPoints[0].y = (int)(trackingRectangle.x*(float)mTrackingOverlay.getHeight()/(float)mMatGrab.cols());
mPoints[0].x = mPoints[1].x - (int)(trackingRectangle.height*(float)mTrackingOverlay.getWidth()/(float)mMatGrab.rows());
mPoints[1].y = mPoints[0].y +(int)(trackingRectangle.width*(float)mTrackingOverlay.getHeight()/(float)mMatGrab.cols());
int centerX = (mPoints[0].x+mPoints[1].x)/2;
int centerY = (mPoints[0].y+mPoints[1].y)/2;
if(centerX-mTrackingOverlay.getWidth()/2 > 150){
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamUp);
}else if(centerX-mTrackingOverlay.getWidth()/2 < -150){
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamDown);
}else{
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestCamStill);
}
// if(centerY-mTrackingOverlay.getHeight()/2 > 200){
// Log.d(TAG, ": " + (centerY-mTrackingOverlay.getHeight()/2) );
// mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestRightTrack);
// }else if(centerY-mTrackingOverlay.getHeight()/2 < -200){
// Log.d(TAG, ": " + (centerY-mTrackingOverlay.getHeight()/2) );
// mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestLeftTrack);
// }
mTrackingOverlay.postInvalidate();
}
}else{
if(mSelectedTrackerPre != "None"){
mUdpClient.sendBytes(mServerAddr, mServerPort, mRequestStop);
}
if (mTracker != null) {
mTracker.clear();
mTracker = null;
}
}
mSelectedTrackerPre = mSelectedTracker;
mTrackingOverlay.invalidate();
}
public void onDestroy() {
Log.e(TAG, "onDestroy");
detectorSSD.requestStop();
detectorSSD.waitForExit();
mWebSocketClient.close();
super.onDestroy();
}
}
| 49.095918
| 171
| 0.514944
|
f60691495217a78d772111493128cca3ea5cf1e3
| 312
|
package org.laeq.model.converter.jackson;
import com.fasterxml.jackson.databind.util.StdConverter;
import org.laeq.model.Category;
public class CategoryConverterSerialize extends StdConverter<Category, Integer> {
@Override
public Integer convert(Category value) {
return value.getId();
}
}
| 26
| 81
| 0.762821
|
614b0c0e061f952530a0ce66a04ed712c38e35bc
| 6,186
|
package util;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import dao.CommDAO;
public class PageManager {
private PageManager() {
}
// 默认一页最大记录数
public static final int DEFAULTPAGESIZE = 20;
// 分页段
public static final int segment = 10;
// 当前页数
protected int currentPage;
// 一页长度
protected int pageSize;
// 总页数
protected long pageNumber;
// 总记录数
protected long count;
// 数据
protected Collection collection;
// 数据查询对象
protected CommDAO dao = new CommDAO();
// 表现层代码
protected String info;
// 请求路径
protected String path;
// 服务器请求对象
protected HttpServletRequest request;
/*
* 仅仅只是加到路径中去
*/
protected String parameter = "";
/**
*
* @param 下一页的分页链接
* @param 一页最大记录数
* @param 当前HttpServletRequest对象
* @param 数据库操作对象
*/
protected PageManager(String path, int pageSize, HttpServletRequest request) {
// 任意一个dao都行
this.currentPage = 1;
this.pageNumber = 1;
this.count = 0;
this.pageSize = pageSize <= 0 ? DEFAULTPAGESIZE : pageSize;
this.request = request;
this.path = path;
request.setAttribute("page", this);
try {
this.currentPage = Integer.parseInt(request
.getParameter("currentPage")) <= 0 ? 1 : Integer
.parseInt(request.getParameter("currentPage"));
} catch (Exception e) {
try {
this.currentPage = Integer.parseInt((String) request
.getSession().getAttribute("currentPage"));
} catch (Exception e1) {
this.currentPage = 1;
}
}
}
/**
*
* @param 下一页的分页链接
* @param 一页最大记录数
* @param 当前HttpServletRequest对象
* @param 数据库操作对象
*/
public static PageManager getPage(String path, int pageSize,
HttpServletRequest request) {
return new PageManager(path, pageSize, request);
}
/**
*
*
* @param hql语句
*
*/
public void doList(String hql) {
String sql = "select count(*) "+hql.substring(hql.indexOf("from"));
sql = sql.substring(0,sql.indexOf("order"));
this.count = this.dao.getInt(sql);
if (this.count != 0) {
this.pageNumber = count % this.pageSize == 0 ? this.count
/ this.pageSize : this.count / this.pageSize + 1;
if (this.currentPage > this.pageNumber)
this.currentPage = (int) this.pageNumber;
}
this.request.getSession().setAttribute("currentPage",
String.valueOf(this.currentPage));
this.collection = this.dao.select(hql,
this.currentPage , this.pageSize);
this.refreshUrl();
}
/**
*
* @param 查询条件集合
* 如没有条件只是列表就不使用这个方法
*/
public void addParameter(List parameter) {
StringBuffer para = new StringBuffer("");
if (parameter != null && parameter.size() != 0) {
Iterator iterator = parameter.iterator();
while (iterator.hasNext()) {
para.append("&").append(iterator.next().toString());
}
}
this.parameter = para.toString();
}
/**
* 刷新分页路径
*
*/
protected void refreshUrl() {
StringBuffer buf = new StringBuffer();
buf.append("<font color='#1157B7'>共").append(count);
buf.append("条");
buf.append(" ");
buf.append("第").append(this.currentPage).append("/").append(
this.pageNumber).append("页");
buf.append(" ");
if (this.currentPage == 1)
buf.append("首页");
else
buf.append("<a href='").append(this.path).append("¤tPage=1")
.append(parameter)
.append("' class='ls'>").append("首页")
.append("</a>");
// ////////////////////////#1157B7
buf.append(" ");
if (this.currentPage > 1) {
buf.append("<a href='").append(this.path).append("¤tPage=")
.append(currentPage - 1).append(parameter).append(
"' class='ls'>").append("上页")
.append("</a>");
} else {
buf.append("上页");
}
buf.append(" ");
int currentSegment = this.currentPage % segment == 0 ? this.currentPage
/ segment : this.currentPage / segment + 1;
/*for (int i = 1; i <= this.pageNumber; i++) {
if (this.currentPage == i)
buf.append("<font color='red'>").append(i).append("</font>");
else
buf.append("<a href='").append(this.path).append(
"¤tPage=").append(i).append(parameter).append(
"' class='ls'>[").append(i).append(
"]</a>");
}*/
buf.append(" ");
if (this.currentPage < this.pageNumber) {
buf.append("<a href='").append(this.path).append("¤tPage=")
.append(currentPage + 1).append(parameter).append(
"' class='ls'>").append("下页")
.append("</a>");
} else {
buf.append("下页");
}
buf.append(" ");
if (this.currentPage == this.pageNumber)
buf.append("末页 ");
else
buf.append("<a href='").append(this.path).append("¤tPage=")
.append(this.pageNumber).append(parameter).append(
"' class='ls'>").append("末页")
.append("</a></font> ");
// ////////////////////
// for (int i = 0; i < this.pageNumber; i++) {
// if (this.currentPage == i + 1) {
// buf.append("<font color=red>[" + (i + 1) + "]</font>").append(
// " ");
// } else {
// buf.append("<a href='").append(this.path).append(
// "¤tPage=").append(i + 1).append(parameter)
// .append("' style='TEXT-DECORATION:none'>").append(
// "[" + (i + 1) + "]").append("</a> ");
// }
// }
buf.append("<select onchange=\"javascript:window.location='").append(
this.path).append("¤tPage='+").append(
"this.options[this.selectedIndex].value").append(parameter)
.append("\">");
for (int i = 0; i < this.pageNumber; i++) {
if (this.currentPage == i + 1)
buf.append("<option value=" + (i + 1)
+ " selected=\"selected\">" + (i + 1) + "</option>");
else
buf.append("<option value=" + (i + 1) + ">" + (i + 1)
+ "</option>");
}
buf.append("</select>");
this.info = buf.toString();
}
public Collection getCollection() {
return collection;
}
public long getCount() {
return count;
}
public int getCurrentPage() {
return currentPage;
}
public long getPageNumber() {
return pageNumber;
}
public int getPageSize() {
return pageSize;
}
public String getInfo() {
return info;
}
}
| 21.93617
| 79
| 0.607986
|
aeb9763077add2d425bfcf0eee65910c365b9355
| 2,309
|
package apijson.demo.server.config;
import apijson.demo.server.common.UtilConstants;
import apijson.demo.server.utils.JwtUtils;
import com.zhangls.apijson.utils.StringUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.SignatureException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
/**
* Created by zhangls on 2019/1/8.
*
* @author zhangls
*/
@Slf4j
@Component
@WebFilter(urlPatterns = "/**", filterName = "standardFilter")
public class StandardFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
log.info("【web容器初始化，调用此方法，预制方法，可初始化数据等操作】");
}
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
log.info("【web容器Filer处理开始，处理全局拦截，如XXS跨站脚本过滤，打印请求日志，记录请求重要信息入库等】");
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
log.debug("【####请求信息#####################################################################】");
log.debug("【客户机IP地址】：{}", request.getRemoteAddr());
log.debug("【客户机端口号】：{}", request.getRemotePort());
log.debug("【客户机主机名】：{}", request.getRemoteHost());
log.debug("【访问全路径】：{}", request.getRequestURL());
log.debug("【访问资源路径】：{}", request.getRequestURI());
log.debug("【RequestedSessionId】：{}", request.getRequestedSessionId());
log.debug("【服务端端口ServerPort】：{}", request.getServerPort());
log.debug("【服务端主机名ServerName】：{}", request.getServerName());
log.debug("【请求方法Method】：{}", request.getMethod());
log.debug("【####请求信息#####################################################################】");
chain.doFilter(request, response);
}
@Override
public void destroy() {
log.info("【web容器Filer销毁方法调用】");
}
}
| 34.984848
| 123
| 0.665656
|
38389c8c67fbde0c87c5f1c48990ae0a0f20111f
| 11,106
|
package org.jeecg.modules.demo.bankstatement.controller;
import java.util.*;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.ss.formula.functions.T;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.demo.bankstatement.entity.BankStatement;
import org.jeecg.modules.demo.bankstatement.service.IBankStatementService;
import org.jeecg.modules.demo.bqrq.controller.DqrqController;
import org.jeecg.modules.demo.bqrq.entity.Dqrq;
import org.jeecg.modules.demo.bqrq.service.IDqrqService;
import org.jeecg.modules.demo.casetable.service.ICaseTableService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
/**
* @Description: 流水表
* @Author: jeecg-boot
* @Date: 2020-02-28
* @Version: V1.0
*/
@Slf4j
@Api(tags = "流水表")
@RestController
@RequestMapping("/bankstatement/bankStatement")
public class BankStatementController extends JeecgController<BankStatement, IBankStatementService> {
@Autowired
private IBankStatementService bankStatementService;
@Autowired
private DqrqController dqrq;
@Autowired
private IDqrqService dqrqService;
@Autowired
private ICaseTableService caseTableService;
/**
* 分页列表查询
*
* @param bankStatement
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "流水表-分页列表查询")
@ApiOperation(value = "流水表-分页列表查询", notes = "流水表-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(BankStatement bankStatement,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
IPage<BankStatement> pageList = null;
if (bankStatement.getReserve1() != null) {
String[] split = bankStatement.getReserve1().split(",");
bankStatement.setReserve1(null);
QueryWrapper<BankStatement> queryWrapper = QueryGenerator.initQueryWrapper(bankStatement, req.getParameterMap());
queryWrapper.orderByAsc("transaction_date");
queryWrapper.between("transaction_date", split[0], split[1]);
Page<BankStatement> page = new Page<BankStatement>(pageNo, pageSize);
pageList = bankStatementService.page(page, queryWrapper);
} else {
QueryWrapper<BankStatement> queryWrapper = QueryGenerator.initQueryWrapper(bankStatement, req.getParameterMap());
queryWrapper.orderByAsc("transaction_date");
Page<BankStatement> page = new Page<BankStatement>(pageNo, pageSize);
pageList = bankStatementService.page(page, queryWrapper);
}
return Result.ok(pageList);
}
/**
* 添加
*
* @param bankStatement
* @return
*/
@AutoLog(value = "流水表-添加")
@ApiOperation(value = "流水表-添加", notes = "流水表-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody BankStatement bankStatement) {
bankStatementService.save(bankStatement);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param bankStatement
* @return
*/
@AutoLog(value = "流水表-编辑")
@ApiOperation(value = "流水表-编辑", notes = "流水表-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody BankStatement bankStatement) {
bankStatementService.updateById(bankStatement);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "流水表-通过id删除")
@ApiOperation(value = "流水表-通过id删除", notes = "流水表-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
bankStatementService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "流水表-批量删除")
@ApiOperation(value = "流水表-批量删除", notes = "流水表-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.bankStatementService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功！");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "流水表-通过id查询")
@ApiOperation(value = "流水表-通过id查询", notes = "流水表-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
BankStatement bankStatement = bankStatementService.getById(id);
return Result.ok(bankStatement);
}
/**
* 导出excel
*
* @param request
* @param bankStatement
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, BankStatement bankStatement) {
return super.exportXls(request, bankStatement, BankStatement.class, "流水表");
}
/**
* 导出excel模板
*
* @param request
* @param bankStatement
*/
@RequestMapping(value = "/exportXls1")
public ModelAndView exportXls1(HttpServletRequest request, BankStatement bankStatement) {
return super.exportXls1(request, bankStatement, BankStatement.class, "流水表");
}
public Result<?> importExcel1(HttpServletRequest request, HttpServletResponse response, Class<BankStatement> clazz) {
String id = request.getParameter("upload");
System.out.println(id+"----------------------");
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<BankStatement> list = ExcelImportUtil.importExcel(file.getInputStream(), clazz, params);
for (int i = 0; i < list.size(); i++) {
list.get(i).setCaseId(id);
}
//update-begin-author:taoyan date:20190528 for:批量插入数据
long start = System.currentTimeMillis();
bankStatementService.saveBatch(list);
//400条 saveBatch消耗时间1592毫秒 循环插入消耗时间1947毫秒
//1200条 saveBatch消耗时间3687毫秒 循环插入消耗时间5212毫秒
//update-end-author:taoyan date:20190528 for:批量插入数据
HashMap<Object, Object> hashMap = new HashMap<>();
Date a = new Date();
hashMap.put("caseId", id);
hashMap.put("createTime",a);
hashMap.put("type", 1);
caseTableService.upCase(hashMap);
//查询几张卡
List<BankStatement> Card = bankStatementService.selectCard(hashMap);
//查询最大日期和最小日期
List<BankStatement> MaxDate = bankStatementService.selectMaxDate();
hashMap.put("MaxDate", MaxDate.get(0).getReserve1());
hashMap.put("MinDate", MaxDate.get(0).getTransactionDate());
Dqrq pp = new Dqrq();
//补全流余额
for (int i = 0; i < Card.size(); i++) {
hashMap.put("queryCardNumber",Card.get(i).getQueryCardNumber());
List<Dqrq> bqrqlist = dqrqService.selectbqrq(hashMap);
double d = 0;
for (int j = 0; j < bqrqlist.size(); j++) {
if(bqrqlist.get(j).getNum() == 0) {
bqrqlist.get(j).setMinbalance(d);
bqrqlist.get(j).setMaxBalance(d);
}else {
hashMap.put("dqsj",bqrqlist.get(j).getDate());
List<BankStatement> MaxBalance = bankStatementService.selectMaxBalance(hashMap);
d = bqrqlist.get(j).getMinbalance();
bqrqlist.get(j).setMaxBalance(bqrqlist.get(j).getMinbalance());
bqrqlist.get(j).setMinbalance(MaxBalance.get(0).getAccountBalance());
}
}
dqrqService.saveBatch(bqrqlist);
System.out.println("------卡号："+bqrqlist.get(0).getQueryCardNumber());
}
//汇总最大金额
int i = bankStatementService.insertMaximumBalance(hashMap);
System.out.println(i + ">>>>>>>");
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
return Result.ok("文件导入成功！数据行数：" + list.size());
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("文件导入失败:" + e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败！");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
Result<?> result = importExcel1(request, response, BankStatement.class);
return result;
}
}
| 39.243816
| 126
| 0.606519
|
1fe23e426119614e73c92223a509032b99d721ec
| 1,190
|
package org.usfirst.frc.team2928.robot.commands;
import org.usfirst.frc.team2928.robot.Robot;
import edu.wpi.first.wpilibj.command.Command;
public class ShootCommand extends Command {
public ShootCommand() {
requires(Robot.shooterSolen);
}
public ShootCommand(String name) {
super(name);
requires(Robot.shooterSolen);
// TODO Auto-generated constructor stub
}
public ShootCommand(double timeout) {
super(timeout);
// TODO Auto-generated constructor stub
}
public ShootCommand(String name, double timeout) {
super(name, timeout);
// TODO Auto-generated constructor stub
}
@Override
protected void initialize() {
// TODO Auto-generated method stub
Robot.shooterSolen.Shoot();
}
@Override
protected void execute() {
// TODO Auto-generated method stub
}
@Override
protected boolean isFinished() {
// TODO Auto-generated method stub
return false;
}
@Override
protected void end() {
Robot.shooterSolen.Retract();
// TODO Auto-generated method stub
}
@Override
protected void interrupted() {
Robot.shooterSolen.Retract();
// TODO Auto-generated method stub
}
}
| 18.888889
| 52
| 0.688235
|
770dfed26e6912647901dfbf7fd7e212a64ebd29
| 2,624
|
package com.egoveris.te.base.helper;
import org.jbpm.api.task.Task;
import org.zkforge.fckez.FCKeditor;
import org.zkoss.bind.BindUtils;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zul.Window;
import com.egoveris.te.base.util.TramitacionHelper;
import com.egoveris.te.web.ee.satra.pl.helpers.states.IVisualState;
public class EnviarPaseHelper {
final TramitacionHelper tramitacionHelper;
final Window sendWindow;
final Window tramWindow;
/**
* Constructor de EnviarPaseHelper
*
* @param tramitacionHelper Helper de tramitacion
* @param sendWindow Ventana de envio de pase
* @param tramWindow Ventana de tramitacion
*/
public EnviarPaseHelper(TramitacionHelper tramitacionHelper, Window sendWindow, Window tramWindow) {
this.tramitacionHelper = tramitacionHelper;
this.sendWindow = sendWindow;
this.tramWindow = tramWindow;
}
/**
* Listener de evento cuando se envia la tramitacion
*
* @return Evento
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public EventListener<Event> onUserEvent() {
return new EventListener() {
@Override
public void onEvent(Event event) {
if ("addDocumentoPase".equals(event.getData())) {
Task workingTask = null;
if (Executions.getCurrent().getDesktop().hasAttribute("selectedTask")) {
workingTask = (Task) Executions.getCurrent().getDesktop().getAttribute("selectedTask");
}
String motivePase = ((FCKeditor) sendWindow.getFellow("motivoExpediente")).getValue();
IVisualState activeState = tramitacionHelper.getActiveState();
//activeState.generateDocumentOfPase(motivePase); // En rigor no deberia ser necesaria esta linea
// Se comenta porque el update de variables tambien se hace dentro de la logica
// de envio de pase
//tramitacionHelper.updateVariables(tramWindow.getFellow("incStatesNombramiento"), workingTask);
activeState.stopReject();
}
BindUtils.postGlobalCommand(null, null, "closeTramitacionWindow", null);
}
};
}
/**
* Listener de evento cuando se cancela o cierra la ventana
* de envio de pase
*
* @return Evento
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public EventListener<Event> onCancelOrExitEvent() {
return new EventListener() {
@Override
public void onEvent(Event event) {
tramitacionHelper.getActiveState().stopReject();
}
};
}
}
| 32.395062
| 107
| 0.68407
|
da216129a1c1c156e76c6692b91a19f3579d16eb
| 2,349
|
/*
* Copyright 2018 the original author or authors.
*
* 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 se.callista.blog.avro_spring.car.conf;
import java.util.List;
import org.apache.avro.specific.SpecificRecordBase;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import se.callista.blog.avro_spring.serde.spring.AvroBinaryHttpMessageConverter;
import se.callista.blog.avro_spring.serde.spring.AvroJsonHttpMessageConverter;
/**
* Configuration required to use the Avro{Binary,Json}HttpMessageConverter.
*
* @author Björn Beskow
*/
@Configuration
public class ConverterConfig extends WebMvcConfigurerAdapter {
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
super.configureMessageConverters(converters);
converters.add(new AvroBinaryHttpMessageConverter<SpecificRecordBase>());
converters.add(new AvroJsonHttpMessageConverter<SpecificRecordBase>());
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
// We need to add the AvroJsonHttpMessageConverter before any generic JSON converter,
// since the pattern a generic JSON converter also may match.
RestTemplate restTemplate = builder.build();
restTemplate.getMessageConverters().add(0, new AvroJsonHttpMessageConverter<SpecificRecordBase>());
restTemplate.getMessageConverters().add(0, new AvroBinaryHttpMessageConverter<SpecificRecordBase>());
return restTemplate;
}
}
| 41.946429
| 106
| 0.778203
|
c83d3bc55bf62b209dee047d0872e4b0243aca24
| 290
|
package lambda.runnable;
public class ThreadEx{
public static void main (String arg[]){
Runnable task = new Runnable(){
@Override
public void run(){
System.out.println("Task #1 is running");
}
};
Thread thread = new Thread(task);
thread.start();
}
}
| 15.263158
| 50
| 0.617241
|
cf98cde32d5f6fb3ca6eb62916f14d7bae2d9b59
| 1,296
|
package com.comcast.pop.modules.queue.api;
import java.util.Collection;
/**
* Limited interface for a queue (based on the java Queue interface)
*/
public interface ItemQueue<T>
{
/**
* Adds the specified item to the Queue
* @param item The item to add
* @return true on success, false otherwise
*/
QueueResult<T> add(T item);
/**
* Adds the specified item to the Queue
* @param items The items to add
* @return true on success, false otherwise
*/
QueueResult<T> add(Collection<T> items);
/**
* Returns the next item of the queue but does not remove it
* @return head of the queue or none if the queue is empty
*/
QueueResult<T> peek();
/**
* Gets the next item of the queue and removes it
* @return head of the queue or none if the queue is empty
*/
QueueResult<T> poll();
/**
* Gets the next number of items, up to the specified max
* @param maxPollCount The maximum number of items to poll the queue for
* @return head maxPollCount (or fewer) items or none if queue is empty
*/
QueueResult<T> poll(int maxPollCount);
/**
* Gets the number of items in the queue
* @return The number of items in the queue
*/
QueueResult<T> size();
}
| 26.44898
| 76
| 0.634259
|
619edfea881ee5d22b1ba01806bc759a66c42f22
| 4,206
|
package reciter.xml.retriever.pubmed;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import reciter.algorithm.util.ReCiterStringUtil;
import reciter.model.identity.AuthorName;
import reciter.model.identity.Identity;
import reciter.pubmed.retriever.PubMedQuery;
import reciter.xml.retriever.pubmed.PubMedQueryType.PubMedQueryBuilder;
/**
* @author Sarbajit Dutta(szd2013)
* @see <a href= "https://github.com/wcmc-its/ReCiter/issues/269">Details here</a>
* This class does lookup in Pubmed based on first two capital letters in Identity names(first or middle)
*/
@Component("secondInitialRetrievalStrategy")
public class SecondInitialRetrievalStrategy extends AbstractNameRetrievalStrategy {
private static final String retrievalStrategyName = "SecondInitialRetrievalStrategy";
private final static Logger slf4jLogger = LoggerFactory.getLogger(SecondInitialRetrievalStrategy.class);
@Override
public String getRetrievalStrategyName() {
return retrievalStrategyName;
}
@Override
protected PubMedQuery buildNameQuery(Set<AuthorName> identitynames, Identity identity) {
PubMedQueryBuilder pubMedQueryBuilder =
new PubMedQueryBuilder(getStrategySpecificKeyword(identity))
.author(false, false, identitynames);
PubMedQuery query = pubMedQueryBuilder.build();
slf4jLogger.info(retrievalStrategyName + " produced query=[" + query + "]");
return query;
}
@Override
protected PubMedQuery buildNameQuery(Set<AuthorName> identitynames, Identity identity, Date startDate,
Date endDate) {
PubMedQueryBuilder pubMedQueryBuilder =
new PubMedQueryBuilder(getStrategySpecificKeyword(identity))
.author(false, false, identitynames)
.dateRange(true, startDate, endDate);
return pubMedQueryBuilder.build();
}
@Override
protected String getStrategySpecificKeyword(Identity identity) {
if (identity.getPrimaryName() != null || (identity.getAlternateNames() != null && !identity.getAlternateNames().isEmpty())) {
String middleName = null;
if(identity.getPrimaryName().getMiddleName() != null) {
middleName = identity.getPrimaryName().getMiddleName();
} else {
middleName = "";
}
String combinedFirstMiddleName = identity.getPrimaryName().getFirstName() + middleName;
String capitalizeFirstMiddle = ReCiterStringUtil.deAccent(combinedFirstMiddleName.chars().filter(Character::isUpperCase)
.mapToObj(c -> Character.toString((char)c))
.collect(Collectors.joining()));
String first = null;
if(capitalizeFirstMiddle.length() >= 2) {
first = identity.getPrimaryName().getLastName() + " " + capitalizeFirstMiddle.substring(0, 2) + "[au]";
}
if(first != null && identity.getAlternateNames() != null && !identity.getAlternateNames().isEmpty()) {
return first;
}
Iterator<AuthorName> iter = identity.getAlternateNames().iterator();
final StringBuilder buf = new StringBuilder();
if(first != null) {
buf.append("(" + first);
} else {
buf.append("(");
}
while(iter.hasNext()) {
AuthorName alternateName = iter.next();
String alternateNameWithInitial = null;
if(alternateName.getMiddleName() != null) {
middleName = alternateName.getMiddleName();
} else {
middleName = "";
}
combinedFirstMiddleName = alternateName.getFirstName() + middleName;
capitalizeFirstMiddle = ReCiterStringUtil.deAccent(combinedFirstMiddleName.chars().filter(Character::isUpperCase)
.mapToObj(c -> Character.toString((char)c))
.collect(Collectors.joining()));
if(capitalizeFirstMiddle.length() >= 2) {
alternateNameWithInitial = alternateName.getLastName() + " " + capitalizeFirstMiddle.substring(0, 2) + "[au]";
}
if(alternateNameWithInitial != null) {
buf.append(alternateNameWithInitial);
buf.append(" OR ");
}
}
buf.append(")");
if(buf.toString().endsWith(" OR )")) {
return buf.toString().substring(0, buf.toString().length() - 5) + ")";
}
else {
return buf.toString();
}
} else {
return null;
}
}
}
| 35.344538
| 127
| 0.72563
|
89dac883e3ad4633b332778df131f37b87ee60b8
| 6,016
|
package com.codepath.apps.twittor;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.resource.bitmap.CircleCrop;
import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
import com.codepath.apps.twittor.databinding.ActivityTweetDetailsBinding;
import com.codepath.apps.twittor.models.Tweet;
import com.codepath.asynchttpclient.callback.JsonHttpResponseHandler;
import org.parceler.Parcels;
import okhttp3.Headers;
/**
* This Activity implements the Tweet Details story.
*/
public class TweetDetailsActivity extends AppCompatActivity {
public static final String TAG = "TweetDetailsActivity";
ActivityTweetDetailsBinding binding;
Tweet tweet;
TwittorClient client;
MenuItem miNetworkProgress;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = ActivityTweetDetailsBinding.inflate(getLayoutInflater());
setContentView(binding.getRoot());
tweet = (Tweet) Parcels.unwrap(getIntent().getParcelableExtra("tweet"));
binding.tvBody.setText(tweet.body);
binding.tvScreenName.setText("(@" + tweet.user.screenName + ")");
binding.tvName.setText(tweet.user.name);
binding.tvTime.setText(Tweet.getRelativeTimeAgo(tweet.createdAt));
Glide.with(this).load(tweet.user.profileImageUrl).transform(new CircleCrop()).into(binding.ivProfileImage);
Glide.with(this).load(tweet.mediaPath).transform(new RoundedCorners(60)).into(binding.ivMedia);
Log.i("TweetsAdapter", "Tweet from" + tweet.user.screenName + " bound");
client = TwittorApp.getRestClient(this);
binding.ivLike.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showProgressBar();
client.likeTweet(tweet.id, new JsonHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Headers headers, JSON json) {
Log.i(TAG, "onSuccess");
hideProgressBar();
Toast toast = Toast.makeText(TweetDetailsActivity.this, "You've liked " + tweet.user.name + "'s tweet!", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP|Gravity.CENTER_HORIZONTAL, 0, 0);
toast.show();
//TODO: change v's color to red! and disable
binding.ivLike.setColorFilter(getResources().getColor(R.color.medium_red));
}
@Override
public void onFailure(int statusCode, Headers headers, String response, Throwable throwable) {
Log.e(TAG, "onFailure" + response, throwable);
Toast toast = Toast.makeText(TweetDetailsActivity.this, "Sorry, unable to like tweet", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP|Gravity.CENTER_HORIZONTAL, 0, 0);
toast.show();
hideProgressBar();
}
});
}
});
binding.ivRetweet.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showProgressBar();
client.retweet(tweet.id, new JsonHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Headers headers, JSON json) {
Log.i(TAG, "onSuccess");
hideProgressBar();
Toast toast = Toast.makeText(TweetDetailsActivity.this, "You've retweeted " + tweet.user.name + "'s tweet!", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP|Gravity.CENTER_HORIZONTAL, 0, 0);
toast.show();
//TODO: turn v green! and disable
binding.ivRetweet.setColorFilter(getResources().getColor(R.color.medium_green));
}
@Override
public void onFailure(int statusCode, Headers headers, String response, Throwable throwable) {
Log.e(TAG, "onFailure" + response, throwable);
Toast toast = Toast.makeText(TweetDetailsActivity.this, "Sorry, unable to retweet", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP|Gravity.CENTER_HORIZONTAL, 0, 0);
toast.show();
hideProgressBar();
}
});
}
});
binding.ivReply.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent i = new Intent(TweetDetailsActivity.this, ComposeActivity.class);
i.putExtra("replyTo", tweet.user.screenName);
startActivity(i);
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
miNetworkProgress = menu.findItem(R.id.miNetworkProgress);
menu.findItem(R.id.compose).setVisible(false);
return true;
}
//TODO: Move these into a helper class!
public void showProgressBar() {
// Show progress item
if (miNetworkProgress != null) {
miNetworkProgress.setVisible(true);
}
}
public void hideProgressBar() {
// Hide progress item
if (miNetworkProgress != null) {
miNetworkProgress.setVisible(false);
}
}
}
| 40.92517
| 152
| 0.606217
|
1a167e002de73607dde8e7bb6c029989d26fd927
| 3,177
|
package hudson.tasks.test;
import edu.hm.hafner.echarts.Build;
import edu.hm.hafner.echarts.BuildResult;
import edu.umd.cs.findbugs.annotations.NonNull;
import hudson.model.Run;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class TestResultActionIterable implements Iterable<BuildResult<AbstractTestResultAction<?>>> {
private final AbstractTestResultAction<?> latestAction;
/**
* Creates a new iterator that selects action of the given type {@code actionType}.
*
* @param baseline
* the baseline to start from
*/
public TestResultActionIterable(final AbstractTestResultAction<?> baseline) {
this.latestAction = baseline;
}
@NonNull
@Override
public Iterator<BuildResult<AbstractTestResultAction<?>>> iterator() {
if (latestAction == null) {
return new TestResultActionIterator(null);
}
return new TestResultActionIterator(latestAction);
}
private static class TestResultActionIterator implements Iterator<BuildResult<AbstractTestResultAction<?>>> {
private AbstractTestResultAction<?> cursor;
private AbstractTestResultAction<?> initialValue;
/**
* Creates a new iterator starting from the baseline.
*
* @param baseline
* the run to start from
*/
TestResultActionIterator(final AbstractTestResultAction<?> baseline) {
initialValue = baseline;
}
@Override
public boolean hasNext() {
if (initialValue != null) {
return true;
}
if (cursor == null) {
return false;
}
AbstractTestResultAction<?> previousBuild = cursor.getPreviousResult(AbstractTestResultAction.class, true);
return previousBuild != null;
}
@Override
public BuildResult<AbstractTestResultAction<?>> next() {
if (initialValue == null && cursor == null) {
throw new NoSuchElementException(
"There is no action available anymore. Use hasNext() before calling next().");
}
AbstractTestResultAction<?> buildAction = getBuildAction();
if (buildAction != null) {
cursor = buildAction;
Run<?, ?> run = cursor.run;
int buildTimeInSeconds = (int) (run.getTimeInMillis() / 1000);
Build build = new Build(run.getNumber(), run.getDisplayName(), buildTimeInSeconds);
return new BuildResult<>(build, buildAction);
}
throw new NoSuchElementException("No more runs with a test result available: " + cursor);
}
private AbstractTestResultAction<?> getBuildAction() {
AbstractTestResultAction<?> run;
if (initialValue != null) {
run = initialValue;
initialValue = null;
} else {
run = cursor.getPreviousResult(AbstractTestResultAction.class, true);
}
return run;
}
}
}
| 34.532609
| 119
| 0.598678
|
758c3de31da2bd5301748a6051a9784fce5920fb
| 1,361
|
package com.redhat.qe.kiali.ui.components;
import com.redhat.qe.kiali.ui.KialiWebDriver;
import com.redhat.qe.kiali.ui.UIAbstract;
/**
* @author Jeeva Kandasamy (jkandasa)
*/
public class Sort extends UIAbstract {
private static final String ORDER_BY_ASC = ".//*[contains(@class, \"sort-direction\") and contains(@class, \"-asc\")]";
private static final String ORDER_BY_DESC = ".//*[contains(@class, \"sort-direction\") and contains(@class, \"-desc\")]";
private String identifier = "//*[contains(@class, \"form-group\")]/button/*[contains(@class, \"sort-direction\")]/..";
public Sort(KialiWebDriver driver) {
this(driver, null);
}
public Sort(KialiWebDriver driver, String identifier) {
super(driver);
if (identifier != null) {
this.identifier = identifier;
}
}
public void ascending() {
orderBy(true);
}
public void descending() {
orderBy(false);
}
public boolean isAscending() {
try {
element(identifier, ORDER_BY_ASC);
return true;
} catch (Exception ex) {
element(identifier, ORDER_BY_DESC);
return false;
}
}
private void orderBy(boolean ascensing) {
if (isAscending() != ascensing) {
element(identifier).click();
}
}
}
| 26.173077
| 125
| 0.59662
|
c65df03edda8b354248cc721478a4882a4600e46
| 2,560
|
package com.wut.pipeline;
import java.util.Map;
import com.wut.model.map.MappedData;
import com.wut.support.settings.SystemSettings;
public class User {
private String customer;
private String id;
private String password;
private String firstName;
private String lastName;
private String token;
private String username;
public static User getPublicUser(String customer) {
User publicUser = new User();
publicUser.setFirstName("Public");
publicUser.setLastName("Public");
publicUser.setUsername("public");
publicUser.setId("public");
publicUser.setPassword("public");
publicUser.setToken("public");
publicUser.setCustomer(customer);
return publicUser;
}
public static User getRetailKitAdminUser(String customer) {
User publicUser = new User();
publicUser.setFirstName(SystemSettings.getInstance().getSetting("defaultUserFirstName"));
publicUser.setLastName(SystemSettings.getInstance().getSetting("defaultUserLastName"));
publicUser.setUsername(SystemSettings.getInstance().getSetting("defaultUserUsername"));
publicUser.setId(SystemSettings.getInstance().getSetting("defaultUserUsername"));
publicUser.setPassword(SystemSettings.getInstance().getSetting("defaultUserPassword"));
publicUser.setToken("");
publicUser.setCustomer(customer);
return publicUser;
}
public String getCustomer() {
return customer;
}
public void setCustomer(String customer) {
this.customer = customer;
}
public String getId() {
return id;
}
public void setId(String username) {
this.id = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public void setUsername(String username) {
this.username = username;
}
public String getUsername() {
return this.username;
}
@Override
public String toString() {
return "User [customer=" + customer + ", id=" + id + ", token=" + token
+ ", username=" + username + "]";
}
public String toJSONString() {
MappedData data = new MappedData();
data.put("customer", customer);
data.put("id", id);
data.put("token", token);
data.put("username", username);
return data.toString();
}
}
| 25.346535
| 91
| 0.730859
|
c7e817e39cd50781f15948c0a7c1c37fa85f8fc1
| 7,489
|
package tests;
import duke.data.Impression;
import duke.data.Investigation;
import duke.data.Medicine;
import duke.data.Observation;
import duke.data.Patient;
import duke.data.PatientData;
import duke.data.Plan;
import duke.data.Result;
import duke.exception.DukeException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class SearchTest {
private Patient patient;
private PatientData patientData;
private static final String duplicateBed = "bedNo";
private static final String pattern1 = "this is my amazingly complex pattern";
private static final String pattern2 = "but wouldn't you think that im cooler";
private static final String pattern3 = "psst they're knaves, i'm the true knight";
private static final String pattern4 = "If there are 2 knights, who is the knight?";
/**
* Sets up the core of this object to have a patient and impression, opens the impression, and stores those
* references for comparison.
*/
@BeforeEach
public void setupTest() {
patientData = new PatientData();
int i = 0;
try {
patientData.addPatient(setupPatient(pattern1, i));
i += 1;
patientData.addPatient(setupPatient(pattern2, i));
Patient temp = patientData.getPatientByBed(duplicateBed + i);
temp.addNewImpression(setUpComplexImpression(pattern3, temp));
temp.addNewImpression(setupImpressionSimple(pattern3, temp));
} catch (DukeException e) {
fail("Exception thrown while setting up basic patient! " + e.getMessage());
}
}
@Test
public void getSearchResultPatientDataTest() {
try {
assertEquals(patientData.findPatients(pattern3).getSearchList().size(), 0);
assertEquals(patientData.findPatients(pattern2).getSearchList().size(), 1);
assertEquals(patientData.searchAll(pattern1).getSearchList().size(), 2);
} catch (DukeException e) {
fail("Could not execute find");
}
}
@Test
public void getSearchResultPatientTest() {
patient = patientData.getPatientByBed(duplicateBed + 1);
patient.update();
assertEquals(patient.findImpressions("testImpression").getSearchList().size(), 1);
assertEquals(patient.searchAll(pattern3).getSearchList().size(), 4);
assertEquals(patient.searchAll(pattern4).getSearchList().size(), 1);
assertEquals(patient.findCriticalsByName("inv").getSearchList().size(), 1);
assertEquals(patient.findCriticalsByName("med blah").getSearchList().size(), 0);
assertEquals(patient.findFollowUpsByName("inv").getSearchList().size(), 1);
}
@Test
public void getSearchResultImpressionTest() {
patient = patientData.getPatientByBed(duplicateBed + 1);
Impression imp = patient.getImpression(pattern3);
assertEquals(imp.findEvidences(pattern4).getSearchList().size(), 0);
assertEquals(imp.findEvidences(pattern1).getSearchList().size(), 1);
assertEquals(imp.findEvidences("").getSearchList().size(), 2);
assertEquals(imp.findEvidences(pattern3).getSearchList().size(), 1);
assertEquals(imp.findEvidences("knight").getSearchList().size(), 1);
assertEquals(imp.searchAll(pattern3).getSearchList().size(), 2);
assertEquals(imp.findEvidences("summary").getSearchList().size(), 2);
assertEquals(imp.findTreatments("knight").getSearchList().size(), 2);
assertEquals(imp.findTreatments("summary").getSearchList().size(), 0);
assertEquals(imp.findTreatmentsByName("sum").getSearchList().size(), 0);
assertEquals(imp.findTreatmentsByName("med").getSearchList().size(), 1);
assertEquals(imp.findEvidencesByName("med").getSearchList().size(), 0);
assertEquals(imp.findEvidencesByName(pattern3).getSearchList().size(), 1);
assertEquals(imp.findByName(pattern3).getSearchList().size(), 2);
}
public Impression setupImpressionSimple(String pattern, Patient parent) {
return new Impression("testImpression", pattern, parent);
}
/**
* Sets up a complex impression.
* @param pattern the pattern to be used for the impression
* @param parent patient
* @return the impression set up
* @throws DukeException if the treatments and evidences cannot be added
*/
public Impression setUpComplexImpression(String pattern, Patient parent) throws DukeException {
Impression imp = new Impression(pattern, "blah", parent);
setupEvidences(pattern3, pattern1, imp);
setupTreatments(pattern3, pattern4, "blah", imp);
return imp;
}
/**
* Sets up Patients.
* @param pattern the pattern to be enbedded in the patient
* @param x to prevent duplicate beds
* @return the patient constructed
*/
public Patient setupPatient(String pattern, int x) {
if (pattern.charAt(0) > 'i') {
return new Patient("name", duplicateBed + x, "allergies", 0, 0,
0, 0, pattern, "");
} else {
return new Patient("name", duplicateBed + x, pattern, 0, 0,
0, 0, "", "");
}
}
/**
* Helper method to create treatments.
*
* @param invName investigation
* @param planName plan
* @param medName medicine
* @throws DukeException duplicate names found
*/
public void setupTreatments(String invName, String planName, String medName, Impression impression)
throws DukeException {
impression.addNewTreatment(createPlan(planName, impression));
impression.addNewTreatment(createInvestigation(invName, impression));
impression.addNewMedicine(createMedicine(medName, impression));
}
/**
* Helper method to create evidences.
*
* @param obsName observation
* @param resName result
* @throws DukeException duplicate names found
*/
private void setupEvidences(String obsName, String resName, Impression impression) throws DukeException {
impression.addNewEvidence(createObservation(obsName, impression));
impression.addNewEvidence(createResult(resName, impression));
}
private Plan createPlan(String name, Impression impression) throws DukeException {
return new Plan("plan " + name, impression, 3, "1", "sum of " + name);
}
private Medicine createMedicine(String name, Impression impression) throws DukeException {
return new Medicine("med " + name, impression, 0, "1", "333",
LocalDate.now().format(DateTimeFormatter.ofPattern("dd MMM yyyy")), "14");
}
private Investigation createInvestigation(String name, Impression impression) throws DukeException {
return new Investigation("inv " + name, impression, 1, "0", "sum of " + name);
}
private Result createResult(String name, Impression impression) throws DukeException {
return new Result("res " + name, impression, 2, "summary of " + name);
}
private Observation createObservation(String name, Impression impression) throws DukeException {
return new Observation("obs " + name, impression, 1, "summary of " + name,
false);
}
}
| 42.310734
| 111
| 0.674456
|
55efd9dbcbb93633a4787a9d6c06496695bedd07
| 1,598
|
package hudson.cli;
import hudson.Extension;
import java.io.PrintStream;
import jenkins.model.Jenkins;
import jenkins.security.SecurityListener;
import org.acegisecurity.Authentication;
import org.kohsuke.args4j.CmdLineException;
/**
* Saves the current credential to allow future commands to run without explicit credential information.
*
* @author Kohsuke Kawaguchi
* @since 1.351
* @deprecated Assumes Remoting, and vulnerable to JENKINS-12543.
*/
@Extension
@Deprecated
public class LoginCommand extends CLICommand {
@Override
public String getShortDescription() {
return Messages.LoginCommand_ShortDescription();
}
@Override
protected void printUsageSummary(PrintStream stderr) {
super.printUsageSummary(stderr);
stderr.println(Messages.LoginCommand_FullDescription());
}
/**
* If we use the stored authentication for the login command, login becomes no-op, which is clearly not what
* the user has intended.
*/
@Override
protected Authentication loadStoredAuthentication() throws InterruptedException {
return Jenkins.ANONYMOUS;
}
@Override
protected int run() throws Exception {
Authentication a = Jenkins.getAuthentication();
if (a== Jenkins.ANONYMOUS)
throw new CmdLineException("No credentials specified."); // this causes CLI to show the command line options.
ClientAuthenticationCache store = new ClientAuthenticationCache(checkChannel());
store.set(a);
SecurityListener.fireLoggedIn(a.getName());
return 0;
}
}
| 29.054545
| 121
| 0.719024
|
7c65dbc00e1b1fa7107e1e4275053cbf6f3b7037
| 1,939
|
/* 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.activiti.idm.engine.delegate.event.impl;
import org.activiti.idm.api.event.ActivitiIdmEvent;
import org.activiti.idm.api.event.ActivitiIdmEventDispatcher;
import org.activiti.idm.api.event.ActivitiIdmEventListener;
import org.activiti.idm.api.event.ActivitiIdmEventType;
/**
* Class capable of dispatching events.
*
* @author Tijs Rademakers
*/
public class ActivitiIdmEventDispatcherImpl implements ActivitiIdmEventDispatcher {
protected ActivitiIdmEventSupport eventSupport;
protected boolean enabled = true;
public ActivitiIdmEventDispatcherImpl() {
eventSupport = new ActivitiIdmEventSupport();
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public boolean isEnabled() {
return enabled;
}
@Override
public void addEventListener(ActivitiIdmEventListener listenerToAdd) {
eventSupport.addEventListener(listenerToAdd);
}
@Override
public void addEventListener(ActivitiIdmEventListener listenerToAdd, ActivitiIdmEventType... types) {
eventSupport.addEventListener(listenerToAdd, types);
}
@Override
public void removeEventListener(ActivitiIdmEventListener listenerToRemove) {
eventSupport.removeEventListener(listenerToRemove);
}
@Override
public void dispatchEvent(ActivitiIdmEvent event) {
if (enabled) {
eventSupport.dispatchEvent(event);
}
}
}
| 29.830769
| 103
| 0.76689
|
494303baf1be8555f5fba66198f0fe43cf7013e0
| 1,780
|
/*
* Copyright 2017 NEOautus Ltd. (http://neoautus.com)
*
* 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.lucidj.accounts;
import org.lucidj.api.core.ManagedObjectFactory;
import org.lucidj.api.core.ManagedObjectInstance;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewProvider;
import org.apache.felix.ipojo.annotations.Component;
import org.apache.felix.ipojo.annotations.Instantiate;
import org.apache.felix.ipojo.annotations.Provides;
import org.apache.felix.ipojo.annotations.Requires;
@Component (immediate = true, publicFactory = false)
@Instantiate
@Provides
public class Accounts implements ViewProvider
{
private final static String NAVID = "accounts";
@Requires
private ManagedObjectFactory object_factory;
@Override // ViewProvider
public String getViewName (String s)
{
if (NAVID.equals (s))
{
return (NAVID);
}
return null;
}
@Override // ViewProvider
public View getView (String s)
{
if (NAVID.equals (s))
{
ManagedObjectInstance view_instance = object_factory.wrapObject (new AccountsView ());
return (view_instance.adapt (AccountsView.class));
}
return null;
}
}
// EOF
| 28.253968
| 98
| 0.710112
|
03f7df0b9fef8c9ba871d78a9f81e503206af994
| 1,576
|
package com.android.flappybird;
import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
public class FlappyBird extends ApplicationAdapter {
private SpriteBatch batch;
private Texture[] passaros;
private Texture fundo;
//Atributos de configuracao
private int larguraDispositivo;
private int alturaDispositivo;
private float variacao = 0;
private float velocidadeQueda=0;
private float posicaoInicialVertical;
@Override
public void create () {
batch = new SpriteBatch();
passaros = new Texture[3];
passaros[0] = new Texture("passaro1.png");
passaros[1] = new Texture("passaro2.png");
passaros[2] = new Texture("passaro3.png");
fundo = new Texture("fundo.png");
larguraDispositivo = Gdx.graphics.getWidth();
alturaDispositivo = Gdx.graphics.getHeight();
posicaoInicialVertical = alturaDispositivo / 2;
}
@Override
public void render () {
variacao += Gdx.graphics.getDeltaTime() * 10 ;
velocidadeQueda++;
if(variacao > 2) variacao = 0;
if(posicaoInicialVertical > 0)
posicaoInicialVertical = posicaoInicialVertical - velocidadeQueda;
batch.begin();
batch.draw(fundo, 0,0, larguraDispositivo , alturaDispositivo );
batch.draw( passaros[ (int) variacao ] , 30, posicaoInicialVertical );
batch.end();
}
}
| 25.419355
| 78
| 0.668782
|
c1f428907d39b7bb163782cb59215e3500528ca8
| 1,681
|
package cn.shiyanjun.platform.scheduled.common;
import com.alibaba.fastjson.JSONObject;
import cn.shiyanjun.platform.api.constants.TaskStatus;
import cn.shiyanjun.platform.api.utils.Time;
import cn.shiyanjun.platform.scheduled.constants.ScheduledConstants;
public final class TaskInfo extends TaskID {
long scheduledTime;
volatile long lastUpdatedTime;
volatile TaskStatus taskStatus;
String platformId;
final TaskID id;
public TaskInfo(TaskID id) {
super(id.jobId, id.taskId, id.seqNo, id.taskType);
this.id = id;
}
public TaskInfo(TaskID id, String platformId) {
super(id.jobId, id.taskId, id.seqNo, id.taskType);
this.id = id;
this.platformId = platformId;
this.lastUpdatedTime = Time.now();
this.scheduledTime = lastUpdatedTime;
this.taskStatus = TaskStatus.SCHEDULED;
}
public TaskStatus getTaskStatus() {
return taskStatus;
}
public void setTaskStatus(TaskStatus taskStatus) {
this.taskStatus = taskStatus;
}
public long getLastUpdatedTime() {
return lastUpdatedTime;
}
public void setLastUpdatedTime(long lastUpdatedTime) {
this.lastUpdatedTime = lastUpdatedTime;
}
public String getPlatformId() {
return platformId;
}
public void setPlatformId(String platformId) {
this.platformId = platformId;
}
@Override
protected JSONObject toJSONObject() {
final JSONObject description = super.toJSONObject();
description.put(ScheduledConstants.PLATFORM_ID, platformId);
description.put(ScheduledConstants.TASK_STATUS, taskStatus);
description.put(ScheduledConstants.LAST_UPDATE_TS, lastUpdatedTime);
return description;
}
@Override
public String toString() {
return toJSONObject().toString();
}
}
| 24.014286
| 70
| 0.766805
|
9c1cd47483d9e4eb019ea8165c01f8d4d110b9c6
| 33,248
|
package net.herit.business.api;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.LinkedBlockingDeque;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.sax.SAXSource;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
import net.herit.business.api.service.ApiHdmDAO;
import net.herit.business.api.service.ApiHdpDAO;
import net.herit.business.api.service.DatabaseService;
import net.herit.business.api.service.FileUploadVO;
import net.herit.business.api.service.LWM2MApiService;
import net.herit.business.api.service.OneM2MApiService;
import net.herit.business.api.service.OpenApiService;
import net.herit.business.api.service.TR069ApiService;
import net.herit.business.device.service.DeviceModelVO;
import net.herit.business.device.service.DeviceVO;
import net.herit.business.device.service.ExtMoProfileVO;
import net.herit.business.device.service.MoProfileVO;
import net.herit.business.device.service.ParameterVO;
import net.herit.business.firmware.service.FirmwareDAO;
import net.herit.business.firmware.service.FirmwareService;
import net.herit.business.protocol.HttpConnector;
import net.herit.business.protocol.Util;
import net.herit.business.protocol.tr069.CurlOperation;
import net.herit.common.conf.HeritProperties;
import net.herit.common.exception.UserSysException;
import net.herit.common.model.ErrorVO;
import net.herit.common.model.HeritFormBasedFileVO;
import net.herit.common.util.HeritFileUploadUtil;
import net.herit.common.util.PagingUtil;
import net.herit.security.dto.GroupAuthorization;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.poi.util.IOUtils;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.eclipse.persistence.jaxb.UnmarshallerProperties;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
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.ResponseBody;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLFilterImpl;
import org.xml.sax.helpers.XMLReaderFactory;
import com.oreilly.servlet.MultipartRequest;
@Controller
@RequestMapping(value = "/api")
public class ApiController {
@Resource(name = "DatabaseService")
private DatabaseService databaseService;
@Resource(name = "OpenApiService")
private OpenApiService openApiService;
@Resource(name = "LWM2MApiService")
private LWM2MApiService lwm2mApiService;
@Resource(name = "TR069ApiService")
private TR069ApiService tr069ApiService;
@Resource(name = "ApiHdmDAO")
private ApiHdmDAO hdmDAO;
@Resource(name="ApiHdpDAO")
private ApiHdpDAO hdpDAO;
@Resource(name = "FirmwareService")
private FirmwareService firmwareService;
@Resource(name = "FirmwareDAO")
private FirmwareDAO fdao;
/** 이미지경로를 위한 URL */
private final String hostUrl = HeritProperties
.getProperty("Globals.hostUrl");
/** 톰캣 위치 지정 */
private final String tomcatDir = HeritProperties
.getProperty("Globals.tomcatDir");
/** 첨부파일 위치 지정 */
private final String uploadDir = HeritProperties
.getProperty("Globals.uploadDir");
private final String firmwareDir = HeritProperties
.getProperty("Globals.firmwareDir");
private final long maxFileSize = 1024 * 1024 * 100;
public final static String INVALID_PARAM = "101";
public final static String DUPLICATED_DEVICE_ID = "102";
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/{data}/{operation}")
public Map<String, Object> get(@PathVariable("system") String system,
@PathVariable("domain") String domain,
@PathVariable("data") String data,
@PathVariable("operation") String operation,
HttpServletRequest request) throws Exception {
//System.out.println("##### get in! "+system+"/"+domain+"/"+data+"/"+operation);
Map<String, Object> response = new HashMap<String, Object>();
HashMap<String, Object> param = new HashMap<String, Object>();
// URL Sample: /hdp/deviceModel/info/get
// URL Sample: /hdm/device/info/list
/*
* HttpSession session = request.getSession(false); if(session != null){
* //페이지 권한 확인 GroupAuthorization requestAuth = (GroupAuthorization)
* session.getAttribute("requestAuth");
* if(!requestAuth.getAuthorizationDBRead().equals("1")){
*
* response.put("result", 505); response.put("errorCode", 505);
* response.put("content", "Permission denied");
* response.put("parameter", param); return response; } }
*/
Enumeration names = request.getParameterNames();
while (names.hasMoreElements()) {
String name = (String) names.nextElement();
String value = request.getParameter(name);
param.put(name, value);
}
//System.out.println(param);
try {
Map<String, Object> content = databaseService.execute(system,
domain, data, operation, param);
//System.out.println(content);
response.put("result", 0);
response.put("errorCode", 0);
response.put("content", content);
response.put("parameter", param);
} catch (UserSysException ex) {
ex.printStackTrace();
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", param);
} catch (Exception ex) {
ex.printStackTrace();
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("parameter", param);
}
return response;
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/{operation}")
public Map<String, Object> execute(
@RequestBody String bodyString,
@PathVariable("system") String system,
@PathVariable("domain") String domain,
@PathVariable("operation") String operation,
HttpServletRequest request) throws Exception {
//System.out.println("##### get in222! "+system+"/"+domain+"/"+operation);
Map<String, Object> response = new HashMap<String, Object>();
HashMap<String, String> param = new HashMap<String, String>();
/*
* HttpSession session = request.getSession(false); if(session != null){
* //페이지 권한 확인 GroupAuthorization requestAuth = (GroupAuthorization)
* session.getAttribute("requestAuth");
* if(!requestAuth.getAuthorizationDBRead().equals("1")){
*
* response.put("result", 505); response.put("errorCode", 505);
* response.put("content", "Permission denied");
* response.put("parameter", param); return response; } }
*/
Enumeration names = request.getParameterNames();
while (names.hasMoreElements()) {
String name = (String) names.nextElement();
String value = request.getParameter(name);
param.put(name, value);
}
//TODO:body 안에 있는 정보를 가져와야 햄.
HashMap<String, Object> contentMap = new ObjectMapper().readValue(bodyString, HashMap.class);
String deviceId = contentMap.containsKey("d") ? (String) contentMap.get("d") : null;
if (deviceId == null || "".equals(deviceId)) {
/** oneM2M 서버에서 검색 */
if (operation.equals("discovery")) {
String sn = (String) contentMap.get("sn");
OneM2MApiService oneM2MSvc = OneM2MApiService.getInstance();
HashMap<String, Object> content = oneM2MSvc.discovery(operation, sn);
ArrayList<HashMap<String, String>> eList = new ArrayList<HashMap<String,String>>();
LinkedHashMap<String, Object> snContent = new LinkedHashMap<String, Object>();
snContent.put("o", "d");
snContent.put("r", "200");//XXX
snContent.put("devId", content);
response.put("result", 0);
response.put("content", snContent);
//System.out.println("response (discovery) : " + response.toString());
return response;
}
}
//System.out.println("deviceId:" + deviceId);
//System.out.println("WHY");
DeviceVO deviceInfo = hdmDAO.getDeviceInfo(deviceId);
//System.out.println("deviceInfo is null? : " + deviceInfo == null);
int dmType = deviceInfo.getDmType();
String extDeviceId = deviceInfo.getExtDeviceId();
String modelName = deviceInfo.getModelName();
DeviceModelVO deviceModelInfo = hdpDAO.getDeviceModelId(modelName);
String deviceModelId = deviceModelInfo.getId();
//System.out.println("dmType : " + dmType);
//System.out.println("extDeviceId : " + extDeviceId);
//System.out.println("modelName : " + modelName);
//System.out.println("deviceModelId : " + deviceModelId);
//System.err.println("#########################################");
//System.err.println(" TEST :: dmType :: "+dmType);
//System.err.println("#########################################");
String body = null;
if (dmType == 0) {
try {
// body = getBody(request);
HashMap<String, Object> content = openApiService.execute(operation, bodyString);
//System.err.println(content.toString());
if (content.get("exception") == null
&& (Integer) content.get("status") == 200) {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
} else if (content.get("exception") == null
&& (Integer) content.get("status") != 200) {
response.put("result", 1);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
} else {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("exception").toString());
// response.put("exception", content.get("exception"));
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
// response.put("json", content.get("json"));
}
} catch (UserSysException ex) {
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", param);
} catch (Exception ex) {
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("requestBody", body);
}
} else if (dmType == 1) {//oneM2M서버
try {
//body data
ArrayList<HashMap<String, String>> resourceList = contentMap.containsKey("e") ? (ArrayList<HashMap<String,String>>) contentMap.get("e") : null;
if (resourceList == null || resourceList.isEmpty()) {
// 예외처리
}
//System.out.println("e:" + resourceList.toString());
ArrayList<String> resUris = new ArrayList<String>();
String executeCont = null;
for (int i=0; i < resourceList.size(); i++) {
//System.out.println("contentList:" + resourceList.get(i));
HashMap<String, String> resUri = resourceList.get(i);
String resource = resUri.get("n");
//System.out.println("resource:" + resource);
//execute 명령에 대한 웹 제어 데이터
executeCont = resUri.get("sv");
//System.out.println("executeCont:" + executeCont);
MoProfileVO moProfileInfo = hdpDAO.getMoProfileId(deviceModelId, resource);
String moProfileId = moProfileInfo.getId();
//System.out.println("moProfileId : " + moProfileId);
ExtMoProfileVO extInfo = hdpDAO.getResUriNameInfo(moProfileId);
//System.out.println("extInfo:" + extInfo.getExtResourceUri());
String resourceUri = extDeviceId +"/"+ extInfo.getExtResourceUri();
//System.out.println("resourceUri:" + resourceUri);
resUris.add(resourceUri);
}
//System.out.println("resUris:" + resUris.toString());
//oneM2M 서버
OneM2MApiService oneM2MSvc = OneM2MApiService.getInstance();
HashMap<String, Object> content = oneM2MSvc.execute(operation, resUris, extDeviceId, executeCont);
//dm서버와 같은 데이터 형식으로 만들어서 구현
ArrayList<String> to = new ArrayList<String>();
ArrayList<String> ct = new ArrayList<String>();
for(int j=0; j < resUris.size(); j++) {
to.add((String) content.get(resUris.get(j)));
ct.add((String) content.get(resUris.get(j)+"_"+j));
//System.out.println(resUris.get(j) + content.get(resUris.get(j)));
//System.out.println(resUris.get(j)+"_"+j + content.get(resUris.get(j)+"_"+j));
}
ArrayList<HashMap<String, String>> eList = new ArrayList<HashMap<String,String>>();
LinkedHashMap<String, Object> resContent = new LinkedHashMap<String, Object>();
HashMap<String, String> resDatas = new HashMap<String, String>();
resContent.put("o", (String)content.get("o"));
resContent.put("r", "200");//XXX
for(int k=0; k < resourceList.size(); k++) {
resDatas = resourceList.get(k);
String resData = resDatas.get("n");
HashMap<String, String> dataMap = new HashMap<String, String>();
dataMap.put("n", resData);
dataMap.put("sv", to.get(k));
dataMap.put("ti", ct.get(k));
eList.add(dataMap);
}
resContent.put("e", eList);
/*ObjectMapper mapper = new ObjectMapper();
Object json = mapper.writeValueAsString(resContent);*/
response.put("result", 0);
response.put("errorCode", "200");
response.put("content", resContent);
////System.out.println("=================" + response.toString());
} catch (Exception ex) {
//System.out.println("ex :" + ex);
}
} else if (dmType == 2) { // LWM2M Server
try {
String op = "r";
if(operation.equals("write")){
op = "e";
} else if(operation.equals("reboot")) {
op = "rb";
}
contentMap.put("o", op);
HashMap<String, Object> content = lwm2mApiService.execute(operation, contentMap, deviceInfo.getAuthId());
//*
if (content.get("exception") == null
&& (Integer) content.get("status") == 200) {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
} else if (content.get("exception") == null
&& (Integer) content.get("status") != 200) {
response.put("result", 1);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
} else {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("exception").toString());
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
}//*/
//System.out.println("CONTENT : " + content.toString());
//System.out.println("RESPONSE : " + response);
} catch (UserSysException ex) {
ex.printStackTrace();
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", param);
} catch (Exception ex) {
ex.printStackTrace();
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("requestBody", body);
}
} else if (dmType == 3) { // TR-069 Server
//System.out.println("##### operation : "+operation);
//System.out.println("##### bodyString : "+bodyString);
//System.out.println("##### contentMap : "+contentMap);
HashMap<String, Object> content = null;
try{
content = tr069ApiService.execute(operation, new JSONObject(bodyString));
//System.out.println("::::::::::::::::::::::::::::::::::");
//System.out.println(content);
if (content.get("exception") == null && (Integer) content.get("status") == 200) {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
} else if (content.get("exception") == null && (Integer) content.get("status") != 200) {
response.put("result", 1);
response.put("errorCode", content.get("status"));
response.put("content", content.get("json"));
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
} else {
response.put("result", 0);
response.put("errorCode", content.get("status"));
response.put("content", content.get("exception").toString());
response.put("requestBody", body);
response.put("responseBody", content.get("body"));
}
} /*catch (UserSysException ex) {
ex.printStackTrace();
//System.out.println(ex);
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", param);
}*/ catch (Exception ex) {
ex.printStackTrace();
//System.out.println(ex);
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("requestBody", body);
}
//System.out.println("[ CONTENT_OUT ] : "+content);
//System.out.println("[ RESPONSE_OUT ] : "+response);
}
return response;
}
// HERE FIRMWARE VERSION INSERT, UPDATE
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/upload")
public String uploadFirmware(
@PathVariable("system") String system,
@PathVariable("domain") String domain,
HttpServletRequest request) {
//throws Exception {
String returnMsg = "success";
Map<String, Object> response = new HashMap<String, Object>();
try{
//System.out.println("##### get in444! "+system+"/"+domain);
String savePath = "";
//System.out.println(firmwareDir);
//System.out.println(tomcatDir+uploadDir);
//System.out.println("ddddddddd3333");
MultipartHttpServletRequest mptRequest = (MultipartHttpServletRequest)request;
String originalFileName = mptRequest.getFile("packageName").getOriginalFilename();
//System.out.println(originalFileName);
File dir = new File(originalFileName);
if (!dir.exists()) {
dir.mkdir();
}
String directory = null;
int fileType = Integer.parseInt(mptRequest.getParameter("fileType").substring(0, mptRequest.getParameter("fileType").indexOf(" ")));
if( fileType == 1 ){
directory = firmwareDir;
} else {
directory = tomcatDir+uploadDir;
}
//System.out.println("middle test : " +dir);
List<HeritFormBasedFileVO> result = HeritFileUploadUtil.filesUpload(request, directory, maxFileSize);
//System.out.println(result.size());
String res = null;
HttpConnector hc = new HttpConnector();
res = hc.sendFile(mptRequest);
//System.out.println("---- res : "+res);
/*
hc.sendFileWithCurl();
if( result.size() > 0 ){
CurlOperation co = new CurlOperation();
co.setHeader("fileType", mptRequest.getParameter("fileType"));
co.setHeader("oui", mptRequest.getParameter("oui"));
co.setHeader("productClass", mptRequest.getParameter("productClass"));
co.setHeader("version", mptRequest.getParameter("version"));
Object[] params = new Object[3];
params[0] = "http://"+HeritProperties.getProperty("Globals.tr069ServerHost")+":"+HeritProperties.getProperty("Globals.tr069ServerPort");
params[1] = co.getHeader();
params[2] = firmwareDir+dir.getName();
res = co.send("file upload", params);
//System.out.println(res);
}*/
if(res != null && res.indexOf("201") > -1){
int deviceModelId = Integer.parseInt(mptRequest.getParameter("deviceModel"));
//long fileSize = dir.length();
long fileSize = result.get(0).getSize();
//System.out.println("######################## file size ");
//System.out.println(fileSize);
int fwId = 0;
String fileName = originalFileName;
String version = mptRequest.getParameter("version");
String description = mptRequest.getParameter("description");
fwId = fdao.getFirmwareId(deviceModelId, fileType);
int fvCount = 0;
if(fwId == 0){
fwId = fdao.addFirmwareInfo(deviceModelId, fileName, fileType, description);
fdao.addFirmwareVersion(fwId, version, fileSize);
} else {
fvCount = fdao.getFirmwareVersionCount(fwId, mptRequest.getParameter("version"));
if(fvCount == 0){
fdao.addFirmwareVersion(fwId, version, fileSize);
}
}
}
} catch (Exception ex) {
ex.printStackTrace();
returnMsg = ex.getMessage();
}
return returnMsg;
}
// HERE FIRMWARE VERSION INSERT, UPDATE
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/{data}/upload")
public Map<String, Object> upload(
@PathVariable("system") String system,
@PathVariable("domain") String domain,
@PathVariable("data") String data, HttpServletRequest request)
throws Exception {
//System.out.println("##### get in333! "+system+"/"+domain+"/"+data);
Map<String, Object> response = new HashMap<String, Object>();
HashMap<String, Object> param = new HashMap<String, Object>();
Enumeration names = request.getParameterNames();
while (names.hasMoreElements()) {
String name = (String) names.nextElement();
String value = request.getParameter(name);
//System.out.println("name value : " + name + " , " + value);
param.put(name, value);
}
FileUploadVO fileUploadVO = new FileUploadVO();
List<FileUploadVO> fileUploadList = new ArrayList();
// List<HeritFormBasedFileVO> list =
// HeritFileUploadUtil.filesUpload(request, fileDir, maxFileSize);
String fileUploadDir = "";
List<HeritFormBasedFileVO> list = null;
if (domain.equalsIgnoreCase("firmware")) {
String dirPackageName = (String) param.get("packageName");
//System.out.println("dirPackageName : " + dirPackageName);
File dir = new File(dirPackageName);
if (!dir.exists()) {
dir.mkdir();
}
String fileDir = firmwareDir + dir;
//System.out.println("fileDir " + fileDir);
fileUploadDir = firmwareDir;
list = HeritFileUploadUtil.filesUpload(request, fileDir,
maxFileSize);
} else {
fileUploadDir = tomcatDir + uploadDir;
list = HeritFileUploadUtil.uploadFiles(request, fileUploadDir,
maxFileSize);
}
if (list.size() > 0) {
for (int i = 0; i < list.size(); i++) {
HeritFormBasedFileVO vo = list.get(i);
fileUploadVO.setFileRealName(vo.getFileName());
fileUploadVO.setFilePhysName(vo.getPhysicalName());
fileUploadVO.setFileSize(String.valueOf(vo.getSize()));
fileUploadList.add(fileUploadVO);
}
}
// js에 보내질 url 경로
// param.put("fileUploadDir", fileUploadDir);
param.put("hostUrl", hostUrl);
param.put("uploadDir", uploadDir);
try {
Map<String, Object> content = databaseService.upload(system,
domain, data, param, fileUploadList);
response.put("result", 0);
response.put("errorCode", 0);
response.put("content", content);
response.put("parameter", param);
} catch (UserSysException ex) {
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", param);
} catch (Exception ex) {
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("parameter", param);
}
return response;
}
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/{data}/{operation}/json")
public Map<String, Object> getJson(
@RequestBody Map<String, Object> paramMap,
@PathVariable("system") String system,
@PathVariable("domain") String domain,
@PathVariable("data") String data,
@PathVariable("operation") String operation,
HttpServletRequest request) throws Exception {
Map<String, Object> response = new HashMap<String, Object>();
HashMap<String, Object> param = new HashMap<String, Object>();
try {
Map<String, Object> content = databaseService.execute(system,
domain, data, operation, paramMap);
response.put("result", 0);
response.put("errorCode", 0);
response.put("content", content);
response.put("parameter", paramMap);
} catch (UserSysException ex) {
ErrorVO err = ex.getErrorVO();
response.put("result", 1);
response.put("errorCode", err.getErrorCode());
response.put("content", err.getErrorMessage());
response.put("parameter", paramMap);
} catch (Exception ex) {
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
response.put("parameter", paramMap);
}
return response;
}
/*public static void main(String[] a) throws JsonGenerationException, JsonMappingException, IOException {
HashMap<String, String> map = new HashMap<String, String>();
map.put("a", "aaa");
map.put("b", "bbb");
ObjectMapper mapper = new ObjectMapper();
Object json = mapper.writeValueAsString(map);
//System.out.println("json: " + json.toString());
}*/
/*
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/{system}/{domain}/{operation}/json")
public Map<String, Object> dbHandler(
@RequestBody String bodyString,
@PathVariable("system") String system,
@PathVariable("domain") String domain,
@PathVariable("operation") String operation,
HttpServletRequest request) throws Exception {
HashMap<String, Object> param = new HashMap<String, Object>();
Enumeration names = request.getParameterNames();
while (names.hasMoreElements()) {
String name = (String) names.nextElement();
String value = request.getParameter(name);
param.put(name, value);
}
return null;
}
*/
@ResponseBody
@RequestMapping(value = "/firmware/list.do")
//public Map<String, Object> getFirmwareList(ParameterVO po, HttpServletRequest request) throws Exception {
public Map<String, Object> getFirmwareList(@RequestBody String bodyString, HttpServletRequest request) throws Exception {
//System.out.println("값 체크");
Map<String, Object> response = new HashMap<String, Object>();
//*
JSONObject param = new JSONObject(bodyString);
//System.out.println(bodyString);
//System.out.println(param);
//System.out.println("@@@@@@@@@@@@@@@@@@@");
ParameterVO po = new ParameterVO();
try{
po.setSn(param.getString("sn"));
po.setDeviceModel(String.valueOf(param.getInt("deviceModel")));
po.setOui(param.getString("oui"));
po.setModelName(param.getString("modelName"));//*/
Method[] methods = po.getClass().getMethods();
for(int i=0; i<methods.length; i++){
if( methods[i].getName().startsWith("get") && methods[i].invoke(po) != null ){
//System.out.println("[PO - "+methods[i].getName()+"] : "+methods[i].invoke(po));
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
PagingUtil pagingUtil = null;
try {
pagingUtil = firmwareService.getFirmwareListPaging(1, 10, po);
response.put("result", 0);
response.put("errorCode", 0);
response.put("pagingUtil", pagingUtil);
} catch (Exception ex) {
ex.printStackTrace();
response.put("result", 1);
response.put("errorCode", -1);
response.put("content", ex.toString());
response.put("exception", ex);
}
return response;
}
// MSH-START
/**
* store "con" value to database when server is received notification
*
* @param request
* @param model
* @return
* @throws Exception
*/
@ResponseBody
@RequestMapping(value = "/onem2m/noti")
public String getConFromNotification(HttpServletRequest request, ModelMap model) {
// map
HashMap<String, String> headers = new HashMap<String, String>();
HashMap<String, String> notification = new HashMap<String, String>();
// headers
Enumeration headerName = request.getHeaderNames();
while( headerName.hasMoreElements() ){
String name = (String)headerName.nextElement();
String value = request.getHeader(name);
headers.put(name, value);
}
Util.getInstance().printMap(headers);
//
String contentType = "json";
String cnf = "text/plain:0";
try(InputStream is = request.getInputStream()){
byte[] buffer = IOUtils.toByteArray(is);
String body = new String(buffer);
//System.out.println(body);
if( (headers.containsKey("Accept") && headers.get("Accept").indexOf("xml") > -1) || body.startsWith("<?xml") ){
contentType = "xml";
}
switch( contentType ){
case "json" :
JSONObject jbody = new JSONObject(body);
notification.put("sur", jbody.getJSONObject("m2m:sgn").getString("sur"));
notification.put("con", jbody.getJSONObject("m2m:sgn").getJSONObject("nev").getJSONObject("rep").getJSONObject("m2m:cin").getString("con"));
if( jbody.getJSONObject("m2m:sgn").getJSONObject("nev").getJSONObject("rep").getJSONObject("m2m:cin").has("cnf") ){
cnf = jbody.getJSONObject("m2m:sgn").getJSONObject("nev").getJSONObject("rep").getJSONObject("m2m:cin").getString("cnf");
}
break;
case "xml" :
notification.put("sur", Util.getValueFromXml(body, "sur"));
notification.put("con", Util.getValueFromXml(body, "con"));
if( Util.getValueFromXml(body, "cnf") != null ){
cnf = Util.getValueFromXml(body, "cnf");
}
break;
default :
//System.out.println("type exception");
return null;
}
notification.put("cnf", cnf);
Util.getInstance().printMap(notification);
boolean isSuccess = hdmDAO.insertNotificationResource(notification);
if( isSuccess ){
//System.out.println(contentType+" - saved");
} else {
//System.out.println(contentType+" - fail to save");
}
} catch(Exception e) {
e.printStackTrace();
}
String result = null;
/*
try(InputStream is = request.getInputStream()){
byte[] buffer = IOUtils.toByteArray(is);
String xml = new String(buffer);
//System.out.println(xml);
HashMap<String, String> notification = new HashMap<String, String>();
notification.put("con", Util.getValueFromXml(xml, "con"));
notification.put("cnf", Util.getValueFromXml(xml, "cnf"));
notification.put("sur", Util.getValueFromXml(xml, "sur"));
Util.getInstance().printMap(notification);
boolean isSuccess = hdmDAO.insertNotificationResource(notification);
if( isSuccess ){
} else {
}
} catch(Exception e) {
e.printStackTrace();
} finally {
}
*/
return result;
}
@ResponseBody
@RequestMapping(value = "/device/type")
public int getDeviceType(HttpServletRequest request, ModelMap model) {
int dmType = 0;
try(InputStream is = request.getInputStream()){
byte[] buffer = IOUtils.toByteArray(is);
//System.out.println(new String(buffer));
JSONObject body = new JSONObject(new String(buffer));
//System.out.println(body);
String deviceId = body.getString("deviceId");
dmType = hdmDAO.getDeviceType(deviceId);
//System.out.println(dmType);
} catch(Exception e) {
e.printStackTrace();
}
return dmType;
}
@ResponseBody
@RequestMapping(value = "/device/model")
public int getDeviceModel(HttpServletRequest request, ModelMap model) {
int dmModelId = 0;
try(InputStream is = request.getInputStream()){
byte[] buffer = IOUtils.toByteArray(is);
//System.out.println(new String(buffer));
JSONObject body = new JSONObject(new String(buffer));
//System.out.println(body);
//
String deviceId = body.getString("deviceId");
dmModelId = hdpDAO.getDeviceModel(deviceId);
//System.out.println(dmModelId);
} catch(Exception e) {
e.printStackTrace();
}
return dmModelId;
}
// MSH-END
}
| 33.583838
| 147
| 0.678296
|
59b5bb2e84992f06659d041be269381d4d170362
| 328
|
package com.dhl.serv.repository;
import com.dhl.serv.domain.ArticleHash;
import org.springframework.data.jpa.repository.*;
import java.util.List;
/**
* Spring Data JPA repository for the ArticleHash entity.
*/
@SuppressWarnings("unused")
public interface ArticleHashRepository extends JpaRepository<ArticleHash,Long> {
}
| 20.5
| 80
| 0.786585
|
741cb93c377eb7c6903288d940d76050ebcdda54
| 6,044
|
package com.zsp.utilone.validate;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Created on 2018/4/11.
*
* @author 郑少鹏
* @desc RegularUtils
*/
public class RegularUtils {
/**
* all numbers
* <p>
* Phone number + IoT number + Data only number
*/
private static final String REGEX_ALL_MOBILE = "^(?:\\+?86)?1(?:3\\d{3}|5[^4\\D]\\d{2}|8\\d{3}|7(?:[01356789]\\d{2}|4(?:0\\d|1[0-2]|9\\d))|9[189]\\d{2}|6[567]\\d{2}|4(?:[14]0\\d{3}|[68]\\d{4}|[579]\\d{2}))\\d{6}$";
/**
* 手机号（精确）
* <p>
* 中国电信号段 133、149、153、173、177、180、181、189、199
* 中国联通号段 130、131、132、145、155、156、166、175、176、185、186
* 中国移动号段 134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188、198
* <p>
* 其它号段
* 14号段前为上网卡专属号段，如中国联通145、中国移动147等。
* <p>
* 虚拟运营商
* 电信：1700、1701、1702
* 移动：1703、1705、1706
* 联通：1704、1707、1708、1709、171
* <p>
* 卫星通信：1349
*/
private static final String REGEX_MOBILE_EXACT = "^((13[0-9])|(14[5,7,9])|(15([0-3]|[5-9]))|(166)|(17[0,1,3,5,6,7,8])|(18[0-9])|(19[8|9]))\\d{8}$";
/**
* all numbers with SMS
* <p>
* Phone number + Data only number
*/
private static final String REGEX_ALL_MOBILE_WITH_SMS = "^(?:\\+?86)?1(?:3\\d{3}|5[^4\\D]\\d{2}|8\\d{3}|7(?:[01356789]\\d{2}|4(?:0\\d|1[0-2]|9\\d))|9[189]\\d{2}|6[567]\\d{2}|4[579]\\d{2})\\d{6}$";
/**
* constructor
*/
private RegularUtils() {
throw new UnsupportedOperationException("You can't instantiate me...");
}
/**
* 电话号码（正则）
*/
private static final String REGEX_TEL = "^0\\d{2,3}[- ]?\\d{7,8}";
/**
* 身份证号码15位（正则）
*/
private static final String REGEX_ID_CARD15 = "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$";
/**
* 身份证号码18位（正则）
*/
private static final String REGEX_ID_CARD18 = "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9Xx])$";
/**
* 邮箱（正则）
*/
private static final String REGEX_EMAIL = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
/**
* URL（正则）
*/
private static final String REGEX_URL = "[a-zA-z]+://[^\\s]*";
/**
* 汉字（正则）
*/
private static final String REGEX_ZH = "^[\\u4e00-\\u9fa5]+$";
/**
* 手机号（精确）
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isMobileExact(CharSequence input) {
return isMatch(REGEX_MOBILE_EXACT, input);
}
/**
* 全手机号
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean allMobile(CharSequence input) {
return isMatch(REGEX_ALL_MOBILE, input);
}
/**
* 符合短信全手机号
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean allMobileWithSms(CharSequence input) {
return isMatch(REGEX_ALL_MOBILE_WITH_SMS, input);
}
/**
* 电话号码
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isTel(CharSequence input) {
return isMatch(REGEX_TEL, input);
}
/**
* 身份证号码15位
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isIdCard15(CharSequence input) {
return isMatch(REGEX_ID_CARD15, input);
}
/**
* 身份证号码18位
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isIdCard18(CharSequence input) {
return isMatch(REGEX_ID_CARD18, input);
}
/**
* 邮箱
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isEmail(CharSequence input) {
return isMatch(REGEX_EMAIL, input);
}
/**
* URL
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isUrl(CharSequence input) {
return isMatch(REGEX_URL, input);
}
/**
* 汉字
*
* @param input 待验文本
* @return true匹/false不匹
*/
public static boolean isZh(CharSequence input) {
return isMatch(REGEX_ZH, input);
}
/**
* 匹正则否
*
* @param regex 正则表达式
* @param input 所匹字符串
* @return true匹/false不匹
*/
private static boolean isMatch(String regex, CharSequence input) {
return input != null && input.length() > 0 && Pattern.matches(regex, input);
}
/**
* 正则匹配部分
*
* @param regex 正则表达式
* @param input 所匹字符串
* @return 正则匹配部分
*/
public static List getMatches(String regex, CharSequence input) {
if (input == null) {
return null;
}
List matches = new ArrayList<>();
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
matches.add(matcher.group());
}
return matches;
}
/**
* 正则匹配分组
*
* @param input 要分组的字符串
* @param regex 正则表达式
* @return 正则匹配分组
*/
public static String[] getSplits(String input, String regex) {
if (input == null) {
return null;
}
return input.split(regex);
}
/**
* 替正则匹配第一部分
*
* @param input 所替字符串
* @param regex 正则表达式
* @param replacement 代替者
* @return 替正则匹配第一部分
*/
public static String getReplaceFirst(String input, String regex, String replacement) {
if (input == null) {
return null;
}
return Pattern.compile(regex).matcher(input).replaceFirst(replacement);
}
/**
* 替所有正则匹配部分
*
* @param input 所替字符串
* @param regex 正则表达式
* @param replacement 代替者
* @return 替所有正则匹配部分
*/
public static String getReplaceAll(String input, String regex, String replacement) {
if (input == null) {
return null;
}
return Pattern.compile(regex).matcher(input).replaceAll(replacement);
}
}
| 24.975207
| 218
| 0.5364
|
cfbe47e724b0469243d256e664c92bf913c8b30f
| 430
|
package timer;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Timer {
// Statement index of Start and End for measurement.
int[] value() default {
/* inclusive */ 0,
/* inclusive */ Integer.MAX_VALUE
};
}
| 25.294118
| 56
| 0.727907
|
9e9868124c16265dd421e5a8f26e47d90c19bea6
| 4,639
|
package io.joshatron.tak.ai.neuralnet;
import io.joshatron.tak.engine.exception.TakEngineException;
import io.joshatron.tak.engine.game.GameState;
import io.joshatron.tak.engine.game.Player;
import io.joshatron.tak.ai.player.SimpleNeuralPlayer;
import java.io.File;
import java.util.ArrayList;
import java.util.Comparator;
/*
* The goal of this class is to compare the different nets to each other to see which is best
* It looks for all json files and runs a round robin tournament, then prints the results
*/
public class CompareNets {
public static void compareAllNets() throws TakEngineException {
ArrayList<NetWithStats> nets = new ArrayList<>();
//Collect all networks
final File netFolder = new File("./");
for(final File file : netFolder.listFiles()) {
if(file.isDirectory()) {
continue;
}
if(file.getName().endsWith(".json")) {
nets.add(NetUtils.getNetFromFile(file));
}
}
if(nets.size() == 0) {
System.out.println("No nets to test. Quitting");
return;
}
//run round robin tournament each player plays each other as both black and white. White always goes first
for(NetWithStats white : nets) {
for(NetWithStats black : nets) {
//don't play against yourself
if(white != black) {
GameState state = new GameState(Player.WHITE, white.getBoardSize());
SimpleNeuralPlayer whitePlayer = new SimpleNeuralPlayer(white.getNet());
SimpleNeuralPlayer blackPlayer = new SimpleNeuralPlayer(black.getNet());
while (!state.checkForWinner().isFinished()) {
if (state.isWhiteTurn()) {
state.executeTurn(whitePlayer.getTurn(state));
} else {
state.executeTurn(blackPlayer.getTurn(state));
}
}
if(state.checkForWinner().getWinner() == Player.WHITE) {
white.addWin();
black.addLoss();
}
else if(state.checkForWinner().getWinner() == Player.BLACK) {
white.addLoss();
black.addWin();
}
else {
white.addLoss();
black.addLoss();
}
}
}
}
int best = 0;
NetWithStats bestNet = nets.get(0);
//display results
for(NetWithStats net : nets) {
System.out.println(net);
System.out.println();
if(net.getWins() > best) {
best = net.getWins();
bestNet = net;
}
}
System.out.println("Best net:");
System.out.println(bestNet);
System.out.println();
//run the analysis
ArrayList<Analysis> inGameRate = new ArrayList<>();
ArrayList<Analysis> afterGameRate = new ArrayList<>();
for(NetWithStats net : nets) {
//in game rate
int index = inGameRate.indexOf(new Analysis(Double.toString(net.getInGameRate())));
if(index == -1) {
Analysis a = new Analysis(Double.toString(net.getInGameRate()));
a.addValue(net.getWins());
inGameRate.add(a);
}
else {
inGameRate.get(index).addValue(net.getWins());
}
//after game rate
index = afterGameRate.indexOf(new Analysis(Double.toString(net.getAfterGameRate())));
if(index == -1) {
Analysis a = new Analysis(Double.toString(net.getAfterGameRate()));
a.addValue(net.getWins());
afterGameRate.add(a);
}
else {
afterGameRate.get(index).addValue(net.getWins());
}
}
inGameRate.sort(Comparator.comparing(Analysis::getName));
afterGameRate.sort(Comparator.comparing(Analysis::getName));
System.out.println("In game rates");
for(Analysis inGame : inGameRate) {
System.out.println(inGame.getName() + ": " + inGame.getAverage());
}
System.out.println();
System.out.println("After game rates");
for(Analysis afterGame : afterGameRate) {
System.out.println(afterGame.getName() + ": " + afterGame.getAverage());
}
}
}
| 35.412214
| 114
| 0.529856
|
83420671467ba3430bb75db75cc566ab444057c5
| 7,276
|
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.hadoop.hive.llap.cli;
import java.io.File;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.yarn.exceptions.YarnException;
import org.apache.slider.client.SliderClient;
import org.apache.slider.common.params.ActionCreateArgs;
import org.apache.slider.common.params.ActionDestroyArgs;
import org.apache.slider.common.params.ActionFreezeArgs;
import org.apache.slider.common.params.ActionInstallPackageArgs;
import org.apache.slider.common.tools.SliderUtils;
import org.apache.slider.core.exceptions.UnknownApplicationInstanceException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.io.Files;
public class LlapSliderUtils {
private static final String SLIDER_GZ = "slider-agent.tar.gz";
private static final Logger LOG = LoggerFactory.getLogger(LlapSliderUtils.class);
public static SliderClient createSliderClient(
Configuration conf) throws Exception {
SliderClient sliderClient = new SliderClient() {
@Override
public void serviceInit(Configuration conf) throws Exception {
super.serviceInit(conf);
initHadoopBinding();
}
};
Configuration sliderClientConf = new Configuration(conf);
sliderClientConf = sliderClient.bindArgs(sliderClientConf,
new String[]{"help"});
sliderClient.init(sliderClientConf);
sliderClient.start();
return sliderClient;
}
public static void startCluster(Configuration conf, String name,
String packageName, Path packageDir, String queue) {
LOG.info("Starting cluster with " + name + ", "
+ packageName + ", " + queue + ", " + packageDir);
SliderClient sc;
try {
sc = createSliderClient(conf);
} catch (Exception e) {
throw new RuntimeException(e);
}
try {
LOG.info("Executing the freeze command");
ActionFreezeArgs freezeArgs = new ActionFreezeArgs();
freezeArgs.force = true;
freezeArgs.setWaittime(3600); // Wait forever (or at least for an hour).
try {
sc.actionFreeze(name, freezeArgs);
} catch (UnknownApplicationInstanceException ex) {
LOG.info("There was no old application instance to freeze");
}
LOG.info("Executing the destroy command");
ActionDestroyArgs destroyArg = new ActionDestroyArgs();
destroyArg.force = true;
try {
sc.actionDestroy(name, destroyArg);
} catch (UnknownApplicationInstanceException ex) {
LOG.info("There was no old application instance to destroy");
}
LOG.info("Executing the install command");
ActionInstallPackageArgs installArgs = new ActionInstallPackageArgs();
installArgs.name = "LLAP";
installArgs.packageURI = new Path(packageDir, packageName).toString();
installArgs.replacePkg = true;
sc.actionInstallPkg(installArgs);
LOG.info("Executing the create command");
ActionCreateArgs createArgs = new ActionCreateArgs();
createArgs.resources = new File(new Path(packageDir, "resources.json").toString());
createArgs.template = new File(new Path(packageDir, "appConfig.json").toString());
createArgs.setWaittime(3600);
if (queue != null) {
createArgs.queue = queue;
}
// See the comments in the method. SliderClient doesn't work in normal circumstances.
File bogusSliderFile = startSetSliderLibDir();
try {
sc.actionCreate(name, createArgs);
} finally {
endSetSliderLibDir(bogusSliderFile);
}
LOG.debug("Started the cluster via slider API");
} catch (YarnException | IOException e) {
throw new RuntimeException(e);
} finally {
try {
sc.close();
} catch (IOException e) {
LOG.info("Failed to close slider client", e);
}
}
}
public static File startSetSliderLibDir() throws IOException {
// TODO: this is currently required for the use of slider create API. Need SLIDER-1192.
File sliderJarDir = SliderUtils.findContainingJar(SliderClient.class).getParentFile();
File gz = new File(sliderJarDir, SLIDER_GZ);
if (gz.exists()) {
String path = sliderJarDir.getAbsolutePath();
LOG.info("Setting slider.libdir based on jar file location: " + path);
System.setProperty("slider.libdir", path);
return null;
}
// There's no gz file next to slider jars. Due to the horror that is SliderClient, we'd have
// to find it and copy it there. Let's try to find it. Also set slider.libdir.
String path = System.getProperty("slider.libdir");
gz = null;
if (path != null && !path.isEmpty()) {
LOG.info("slider.libdir was already set: " + path);
gz = new File(path, SLIDER_GZ);
if (!gz.exists()) {
gz = null;
}
}
if (gz == null) {
path = System.getenv("SLIDER_HOME");
if (path != null && !path.isEmpty()) {
gz = new File(new File(path, "lib"), SLIDER_GZ);
if (gz.exists()) {
path = gz.getParentFile().getAbsolutePath();
LOG.info("Setting slider.libdir based on SLIDER_HOME: " + path);
System.setProperty("slider.libdir", path);
} else {
gz = null;
}
}
}
if (gz == null) {
// This is a terrible hack trying to find slider on a typical installation. Sigh...
File rootDir = SliderUtils.findContainingJar(HiveConf.class)
.getParentFile().getParentFile().getParentFile();
File sliderJarDir2 = new File(new File(rootDir, "slider"), "lib");
if (sliderJarDir2.exists()) {
gz = new File(sliderJarDir2, SLIDER_GZ);
if (gz.exists()) {
path = sliderJarDir2.getAbsolutePath();
LOG.info("Setting slider.libdir based on guesswork: " + path);
System.setProperty("slider.libdir", path);
} else {
gz = null;
}
}
}
if (gz == null) {
throw new IOException("Cannot find " + SLIDER_GZ + ". Please ensure SLIDER_HOME is set.");
}
File newGz = new File(sliderJarDir, SLIDER_GZ);
LOG.info("Copying " + gz + " to " + newGz);
Files.copy(gz, newGz);
newGz.deleteOnExit();
return newGz;
}
public static void endSetSliderLibDir(File newGz) throws IOException {
if (newGz == null || !newGz.exists()) return;
LOG.info("Deleting " + newGz);
newGz.delete();
}
}
| 38.497354
| 96
| 0.672622
|
f09de5d0317dfa263d800a25a60e907565d64b5b
| 3,433
|
package com.example.hy.recruitnew;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.os.Build;
import android.os.Bundle;
import android.view.DisplayCutout;
import android.view.View;
import android.view.WindowManager;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.RotateAnimation;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.constraintlayout.widget.Guideline;
import androidx.interpolator.view.animation.FastOutSlowInInterpolator;
import androidx.viewpager.widget.ViewPager;
import butterknife.BindView;
import butterknife.ButterKnife;
public class LaunchActivity extends AppCompatActivity implements Animation.AnimationListener {
@BindView(R.id.iv_bg)
ImageView ivBg;
@BindView(R.id.iv_recruit)
ImageView ivRecruit;
@BindView(R.id.tv_recruit)
TextView tvRecruit;
@BindView(R.id.gl_v)
Guideline glV;
@BindView(R.id.iv_rdc)
ImageView ivRdc;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
setContentView(R.layout.activity_launch);
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.P){
View decorView = getWindow().getDecorView();
decorView.post(() -> {
DisplayCutout cutout = decorView.getRootWindowInsets().getDisplayCutout();
if(cutout != null && cutout.getBoundingRects() != null){
WindowManager.LayoutParams lp = getWindow().getAttributes();
lp.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
getWindow().setAttributes(lp);
}
});
}
ButterKnife.bind(this);
AlphaAnimation aa = new AlphaAnimation(0.5f, 1.0f);
aa.setDuration(3000);
aa.setAnimationListener(this);
ivBg.startAnimation(aa);
ScaleAnimation sa = new ScaleAnimation(0, 1, 0, 1, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
sa.setDuration(1200);
ivRecruit.startAnimation(sa);
RotateAnimation ra = new RotateAnimation(180, 360, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
ra.setDuration(1200);
tvRecruit.startAnimation(ra);
TranslateAnimation ta = new TranslateAnimation(0, 0, 1500, 0);
ta.setDuration(1200);
ta.setInterpolator(new FastOutSlowInInterpolator());
ivRdc.startAnimation(ta);
}
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
Intent intent = new Intent(LaunchActivity.this, MainActivity.class);
startActivity(intent);
overridePendingTransition(R.anim.anim_open_enter, R.anim.anim_open_exit);
finish();
}
@Override
public void onAnimationRepeat(Animation animation) {
}
}
| 35.030612
| 127
| 0.709583
|
22a9b20bebc7f9d693d01b9943b1c51be0570715
| 1,109
|
package com.badugi.game.logic.model.vo.supreme;
import java.io.Serializable;
import java.util.List;
public class DealerResultVo implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private String cmd;
private Long fbId;
private Long totalWinChips;
private List<DealerWinVo> dealerWinList;
public DealerResultVo(){}
public DealerResultVo(String cmd,Long fbId,Long totalWinChips,List<DealerWinVo> dealerWinList){
this.cmd = cmd;
this.fbId = fbId;
this.totalWinChips = totalWinChips;
this.dealerWinList = dealerWinList;
}
public Long getFbId() {
return fbId;
}
public void setFbId(Long fbId) {
this.fbId = fbId;
}
public Long getTotalWinChips() {
return totalWinChips;
}
public void setTotalWinChips(Long totalWinChips) {
this.totalWinChips = totalWinChips;
}
public List<DealerWinVo> getDealerWinList() {
return dealerWinList;
}
public void setDealerWinList(List<DealerWinVo> dealerWinList) {
this.dealerWinList = dealerWinList;
}
public String getCmd() {
return cmd;
}
public void setCmd(String cmd) {
this.cmd = cmd;
}
}
| 23.104167
| 96
| 0.744815
|
c2510ecb550563af559f3abb162b3794548e1f76
| 1,573
|
package com.javarush.task.task24.task2407;
/*
В работе вам иногда будет нужно закастить класс к какому-нибудь интерфейсу (тут Sayable),
который не реализован в текущем классе
*/
public class Cat implements Pet {
private String name;
public Cat(String name) {
this.name = name;
}
/**
* Это - механизм адаптирования к другому интерфейсу - Sayable
* Внутри метода toSayable создайте class CatPet, реализующий интерфейс Sayable
* Логика метода say:
* Если i < 1, то вывести на экран, что кот спит. Пример, "Васька спит."
* Иначе вывести фразу: "имя_кота говорит мяу!". Пример для i=3, "Васька говорит мяяяу!"
* <p/>
* <b>Пример вывода:</b>
* Мурзик спит.
* Васька говорит мяяу!
* Кошка говорит мяяяяяу!
* Мышь пищит.
* Томас говорит мяу!
* <p/>
*
* @param i количество букв 'я' в слове мяу
* @return экземпляр класса CatPet
*/
public Sayable toSayable(final int i) {
final String nam = name;
class CatPet implements Sayable {
@Override
public String say() {
String res;
if (i < 1) {
res = name + " спит.";
} else {
res = name + " говорит м";
for (int j=0; j< i; j++) {
res = res + "я";
}
res = res + "у!";
}
return res;
}
}
CatPet catPet = new CatPet();
return catPet;
}
}
| 28.089286
| 92
| 0.516847
|
18f0f824738fa0b6a0be515a904790b9391d0d2f
| 1,883
|
/*******************************************************************************
* Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Blaise Doughan - 2.3 - initial implementation
******************************************************************************/
package org.eclipse.persistence.testing.jaxb.annotations.xmlpath.predicate;
import org.eclipse.persistence.testing.jaxb.JAXBTestCases;
public class ReferenceTestCases extends JAXBTestCases {
private static final String XML_RESOURCE = "org/eclipse/persistence/testing/jaxb/annotations/xmlpath/predicate/reference.xml";
public ReferenceTestCases(String name) throws Exception {
super(name);
setClasses(new Class[] {ReferenceRoot.class});
setControlDocument(XML_RESOURCE);
}
@Override
protected ReferenceRoot getControlObject() {
ReferenceRoot root = new ReferenceRoot();
ReferenceChild rc1 = new ReferenceChild();
rc1.setId("1");
root.getChildren().add(rc1);
ReferenceChild rc2 = new ReferenceChild();
rc2.setId("2");
rc2.setParent(rc1);
rc1.getChildren().add(rc2);
root.getChildren().add(rc2);
ReferenceChild rc3 = new ReferenceChild();
rc3.setId("3");
rc3.setParent(rc1);
rc1.getChildren().add(rc3);
root.getChildren().add(rc3);
return root;
}
}
| 37.66
| 131
| 0.618694
|
6e806c428d8ffb203cd27fbfe40915c55c20d5c0
| 14,270
|
/*
* Copyright (C) 2017 by Fonoster Inc (http://fonoster.com)
* http://github.com/fonoster/astive
*
* This file is part of Astive
*
* 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 com.fonoster.astive.menu;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.apache.log4j.Logger;
import com.fonoster.astive.agi.AgiException;
import com.fonoster.astive.agi.AgiResponse;
import com.fonoster.astive.agi.CommandProcessor;
import com.fonoster.astive.menu.action.Action;
import com.fonoster.astive.menu.event.ActionEvent;
import com.fonoster.astive.menu.event.AuthenticationEvent;
import com.fonoster.astive.menu.event.DigitsEvent;
import com.fonoster.astive.menu.event.FailEvent;
import com.fonoster.astive.menu.event.InterDigitsTimeoutEvent;
import com.fonoster.astive.menu.event.KeyEvent;
import com.fonoster.astive.menu.event.MaxFailureEvent;
import com.fonoster.astive.menu.event.MaxTimeoutEvent;
import com.fonoster.astive.menu.event.PositionChangeEvent;
/**
* The engine of Menu API. It eliminate the necessity of the loops commonly
* needed by AGI, when creating user iteration/navigation.
*
* @since 1.0
*/
public class MenuNavigator {
private static final Logger LOG = Logger.getLogger(MenuNavigator.class);
private AgiResponse agiResponse;
private Menu currentMenu;
private boolean answered;
private boolean autoAnswer;
/**
* Creates a new instance of MenuNavigator.
*
* @param agiResponse allows user iteration with telephony system.
*/
public MenuNavigator(AgiResponse agiResponse) {
this.agiResponse = agiResponse;
autoAnswer = true;
answered = false;
}
private void authenticate(MenuItem item) {
if (item.getMustAuthenticate()) {
if (!item.getAuthenticator().isAuthenticated()) {
AuthenticationEvent evt = new AuthenticationEvent(item, item.getAuthenticator());
item.getAuthenticator().signIn();
if (item.getAuthenticator().isAuthenticated()) {
item.fireAuthenticationEvent_onSuccess(null);
} else {
item.fireAuthenticationEvent_onFailure(evt);
}
}
}
}
private boolean checkMaxFailure(Menu menu, String opt) {
if (menu.getFailuresCount() >= menu.getMaxFailures()) {
MaxFailureEvent event = new MaxFailureEvent(menu, opt, menu.getMaxFailures());
menu.fireMaxFailureEvent_maxFailurePerform(event);
// do break the flow
return true;
}
return false;
}
private boolean checkMaxTimeout(Menu menu, String opt) {
if (menu.getTimeoutCount() >= menu.getMaxTimeouts()) {
MaxTimeoutEvent event = new MaxTimeoutEvent(menu, opt, menu.getMaxTimeouts());
menu.fireMaxTimeoutEvent_maxTimeoutPerform(event);
// do break the flow
return true;
}
return false;
}
private ArrayList<String> getChildsKeys(ArrayList<MenuItem> menuChilds) {
ArrayList<String> result = new ArrayList<String>();
for (MenuItem child : menuChilds) {
final String digits = ((MenuItem) child).getDigits();
result.add(digits);
}
return result;
}
private Menu getCurrentMenu() {
return currentMenu;
}
private String getData(String file, int milliSecondsWatting, int maxDigits,
AgiResponse agiResponse, MenuItem item, char c)
throws AgiException {
Menu menu;
String result = new String();
if (item.getParent() != null) {
menu = ((Menu) item.getParent());
} else {
menu = getCurrentMenu();
}
// Has not press any key
if (c == 0) {
// WARNING: Not sure about using all keys...
c = agiResponse.streamFile(file, "0123456789*#");
if (c == 0 /*
* && milliSecondsWatting == 0
*/) {
try {
Thread.sleep(milliSecondsWatting);
} catch (InterruptedException ex) {
LOG.warn(ex.getMessage());
}
return "(timeout)";
}
} else {
result = "" + c;
c = agiResponse.waitForDigit(menu.getInterDigitsTimeout());
}
KeyEvent evt;
if (c != 0) {
evt = new KeyEvent(item, Digit.getDigit(c));
item.fireKeyEvent_keyTyped(evt);
result += ("" + c);
}
while (true) {
if ((result.length() == maxDigits) || (c == '#')) {
return result;
}
c = agiResponse.waitForDigit(menu.getInterDigitsTimeout());
if (c != 0) {
result += ("" + c);
evt = new KeyEvent(item, Digit.getDigit(c));
item.fireKeyEvent_keyTyped(evt);
} else {
InterDigitsTimeoutEvent event =
new InterDigitsTimeoutEvent(item, result, menu.getInterDigitsTimeout());
menu.fireInterDigitsTimeoutListener_timeoutPerform(event);
break;
}
}
return result;
}
private MenuItem getMenuItem(Menu menu, String digits) {
for (MenuItem item : menu.getChilds()) {
if (item.getDigits().equals(digits)) {
return item;
}
}
return null;
}
// XXX: Im not sure about this criteria
private ArrayList<String> getSortedChildsKeys(ArrayList<MenuItem> menuChilds) {
ArrayList result = new ArrayList();
Comparator comparator =
new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int c1 = ((MenuItem) o1).getPriority();
int c2 = ((MenuItem) o2).getPriority();
return (new Integer(c1)).compareTo(new Integer(c2));
}
;
};
Object[] opts = new Object[menuChilds.size()];
int cnt = 0;
for (MenuItem child : menuChilds) {
opts[cnt++] = child;
}
// Sorting the items
Arrays.sort(opts, comparator);
for (int i = 0; i < opts.length; i++) {
String digits = ((MenuItem) opts[i]).getDigits();
result.add(digits);
}
return result;
}
private Boolean isAutoAnswer() {
return autoAnswer;
}
/**
* Start the menu execution.
*
* @param menu and object containing all menu and menu items.
*/
public void run(Menu menu) throws AgiException {
String digits = null;
setCurrentMenu(menu);
// If channel is closed by customer the player must be auto-halt.
if (agiResponse.getChannelStatus().getCode() == -1) {
return;
}
// WARNING: To be reviewed
if ((answered == false) && (isAutoAnswer() == true)) {
agiResponse.answer();
answered = true;
}
ArrayList<String> childsKeys;
// Sort elements
if (!menu.isSortChildsByDigits()) {
childsKeys = getChildsKeys(menu.getChilds());
} else {
childsKeys = getSortedChildsKeys(menu.getChilds());
}
if (LOG.isDebugEnabled()) {
LOG.debug("Total menu options: " + menu.getChilds().size());
}
if (((menu.isGreetingsPlayed() == false) || menu.isPlayGreetingsAllways())
&& (menu.getGreetingsFile() != null) && !menu.getGreetingsFile().isEmpty()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Playing menu intro: " + menu.getGreetingsFile());
}
char c = 0;
digits = getData(menu.getGreetingsFile(), 0, menu.getMaxDigits(), agiResponse, menu, c);
menu.setGreetingsPlayed(true);
}
if ((digits == null) || digits.equals("(timeout)")) {
List<VoiceComposition> voiceCompositions = menu.getVoiceCompositions();
Iterator<VoiceComposition> vcIterator = voiceCompositions.iterator();
char c = 0;
while (vcIterator.hasNext()) {
VoiceComposition cVc = vcIterator.next();
Iterator<Object> commands = cVc.getCommands().iterator();
while (commands.hasNext()) {
Object o = commands.next();
String cmd = CommandProcessor.buildCommand(o);
c = agiResponse.sendAgiCommand(cmd).getResultCodeAsChar();
if (c != 0) {
KeyEvent evt = new KeyEvent(menu, Digit.getDigit(c));
menu.fireKeyEvent_keyTyped(evt);
digits = getData(menu.getFile(), 0, menu.getMaxDigits(), agiResponse, menu, c);
break;
}
}
if (c != 0) {
break;
}
}
}
if ((digits == null) || digits.equals("(timeout)")) {
if (LOG.isDebugEnabled()) {
LOG.debug("Playing menu options");
}
int pos = 0;
for (String opts : childsKeys) {
MenuItem option = getMenuItem(menu, opts);
int millisecondsWatting = menu.getInterDigitsTimeout();
if (((menu.getChilds().size() - 1) >= 0)
&& menu.getChilds().get(menu.getChilds().size() - 1).equals(option)) {
millisecondsWatting = menu.getLastDigitsTimeout();
}
if ((digits == null) || digits.equals("(timeout)")) {
// Waiting time in between the item file and digits item file.
int msw;
msw = millisecondsWatting;
if ((option.getFile() != null) && !option.getFile().isEmpty()) {
char c = 0;
digits = getData(option.getFile(), msw, menu.getMaxDigits(), agiResponse, menu, c);
}
}
MenuItem oldOption = option;
if (pos > 0) {
oldOption = getMenuItem(menu, childsKeys.get(pos - 1));
}
PositionChangeEvent evt = new PositionChangeEvent(oldOption, option, pos - 1);
menu.firePositionChangeEvent_positionChange(evt);
pos++;
if (LOG.isDebugEnabled()) {
LOG.debug("pos = " + pos);
}
}
}
if ((digits != null) && !digits.equals("(timeout)")) {
// Do break menu
if (LOG.isDebugEnabled()) {
LOG.debug("Enter digits is: " + digits);
}
// WARNING: Should this event be only at Menu level?
DigitsEvent evt = new DigitsEvent((Object) menu, digits);
menu.fireDigitsEvent_digitsEnter(evt);
}
// Selected none option
if ((digits == null) || digits.equals("(timeout)")) {
// XXX: Not only timeout, but also for # sign.
if (digits == null) {
FailEvent evt = new FailEvent(menu, digits, menu.getFailuresCount());
menu.fireFailureListener_failurePerform(evt);
} else if (digits.equals("(timeout)")) {
// WARNNING:
//menu.fireTimeoutListener_timeoutPerform(null);
}
// Try again
if (LOG.isDebugEnabled()) {
LOG.debug("Unregistered option");
}
menu.incrementFailuresCount();
if (!checkMaxFailure(menu, digits) && !checkMaxTimeout(menu, digits)) {
run(menu);
return;
}
if ((menu.getExitFile() != null) && !menu.getExitFile().isEmpty()) {
agiResponse.streamFile(menu.getExitFile());
}
return;
}
if (LOG.isDebugEnabled()) {
LOG.debug("Getting Menu/MenuItem for digits: " + digits);
}
MenuItem selectedOption = getMenuItem(menu, digits);
if (selectedOption != null) {
menu.resetFailuresCount();
menu.resetTimeoutCount();
Action action = selectedOption.getAction();
if (action != null) {
authenticate(selectedOption);
selectedOption.getAction().doAction();
}
ActionEvent evt = new ActionEvent(selectedOption, digits);
selectedOption.fireActionEvent_processAction(evt);
if (selectedOption instanceof Menu) {
run((Menu) selectedOption);
} else {
run(menu);
}
return;
} else {
// Invalid option
if ((menu.getInvalidDigitsFile() != null) && !menu.getInvalidDigitsFile().isEmpty()) {
agiResponse.streamFile(menu.getInvalidDigitsFile());
}
menu.incrementFailuresCount();
if (!checkMaxFailure(menu, digits) && !checkMaxTimeout(menu, digits)) {
run(menu);
return;
}
if ((menu.getExitFile() != null) && !menu.getExitFile().isEmpty()) {
agiResponse.streamFile(menu.getExitFile());
}
return;
}
}
private void setCurrentMenu(Menu currentMenu) {
this.currentMenu = currentMenu;
}
}
| 32.21219
| 107
| 0.54555
|
ae54e1530b92350af612c1966b7f9ab4d8380f0a
| 401
|
package com.example.xiacijie.feelsbook;
import java.util.Comparator;
/** a helper class
* that do the object sorting */
public class ObjectSortUtil implements Comparator<Feel> {
// https://stackoverflow.com/questions/2784514/sort-arraylist-of-custom-objects-by-property
@Override
public int compare(Feel o1, Feel o2) {
return o2.getRawDate().compareTo(o1.getRawDate());
}
}
| 26.733333
| 94
| 0.725686
|
2fa5e64008fcd7e2c51cd53c68e3e032f108e8e9
| 97
|
@Import("com.typesafe.scalalogging")
package org.veripacks.data.t8;
import org.veripacks.Import;
| 24.25
| 36
| 0.804124
|
3ff2c7f30df0dcdd17b4a3d49495f250cb127d92
| 2,289
|
package net.veierland.aixd;
import net.veierland.aixd.R;
import android.app.Activity;
import android.app.ProgressDialog;
import android.net.Uri;
import android.os.Bundle;
import android.view.Window;
import android.webkit.WebView;
import android.webkit.WebViewClient;
public class AixIntro extends Activity {
public final static String ACTION_SHOW_HELP = "aix.intent.action.SHOW_HELP";
public final static String ACTION_SHOW_INTRODUCTION = "aix.intent.action.SHOW_INTRODUCTION";
public final static String ACTION_SHOW_DEVICE_PROFILE_GUIDE = "aix.intent.action.SHOW_DEVICE_PROFILE_GUIDE";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.intro);
Uri uri = getIntent().getData();
String loadingMessage = null, url = null;
if (uri != null && uri.equals(ACTION_SHOW_HELP))
{
url = "https://www.veierland.net/aix/help/?https";
loadingMessage = "Loading Aix help..";
}
else if (uri != null && uri.equals(ACTION_SHOW_DEVICE_PROFILE_GUIDE))
{
url = "https://www.veierland.net/aix/device_profiles/?https";
loadingMessage = "Loading Device Profile guide..";
}
else
{
// Show intro as default
url = "https://www.veierland.net/aix/introduction/?https";
loadingMessage = "Loading Aix introduction..";
}
WebView web = findViewById(R.id.webview);
final ProgressDialog progressBar = ProgressDialog.show(this, "Aix Weather Widget", loadingMessage);
web.setWebViewClient(new WebViewClient() {
public void onPageFinished(WebView view, String url) {
if (progressBar.isShowing()) {
progressBar.dismiss();
}
}
public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
if (failingUrl.startsWith("https://")) {
view.loadUrl(failingUrl.replace("https://", "http://").concat("?http"));
}
}
public boolean shouldOverrideUrlLoading(WebView view, String url){
view.loadUrl(url);
return false;
}
});
web.loadUrl(url);
}
}
| 31.791667
| 109
| 0.662735
|
a907507a2847dd485f2b55ba9d1154167c834e8f
| 1,480
|
package one.jodi.action;
import com.google.inject.Inject;
import one.jodi.base.bootstrap.ActionRunner;
import one.jodi.base.bootstrap.RunConfig;
import one.jodi.base.bootstrap.UsageException;
import one.jodi.bootstrap.EtlRunConfig;
import one.jodi.etl.service.interfaces.TransformationPrintServiceProvider;
import java.io.File;
public class PrintTransformationServiceActionRunner implements ActionRunner {
private final TransformationPrintServiceProvider printServiceProvider;
@Inject
public PrintTransformationServiceActionRunner(final TransformationPrintServiceProvider printServiceProvider) {
this.printServiceProvider = printServiceProvider;
}
@Override
public void run(RunConfig config) {
validateRunConfig(config);
this.printServiceProvider.print(((EtlRunConfig) config).getFolder(), ((EtlRunConfig) config).getPrefix());
}
@Override
public void validateRunConfig(RunConfig config) throws UsageException {
if (config.getPropertyFile() == null ||
!new File(config.getPropertyFile()).exists()) {
String msg = "Properties file should be specified and exist.";
throw new UsageException(msg);
}
if (config.getMetadataDirectory() == null ||
!new File(config.getMetadataDirectory()).exists()) {
String msg = "Metadata directory should be specified and exist.";
throw new UsageException(msg);
}
}
}
| 36.097561
| 114
| 0.716216
|
fdfcb960c4ed2adc7129960e6d110d3b6666a0b6
| 1,176
|
// This file is part of PDQ (https://github.com/ProofDrivenQuerying/pdq) which is released under the MIT license.
// See accompanying LICENSE for copyright notice and full details.
package uk.ac.ox.cs.pdq.planner.linear.explorer.node.metadata;
import uk.ac.ox.cs.pdq.planner.linear.explorer.SearchNode;
// TODO: Auto-generated Javadoc
/**
* The Class CreationMetadata.
*
* @author Efthymia Tsamoura
*/
public class CreationMetadata extends Metadata{
/** The time created. */
protected final double timeCreated;
/**
* Instantiates a new creation metadata.
*
* @param parent the parent
* @param timeCreated the time created
*/
public CreationMetadata(SearchNode parent, double timeCreated) {
super(parent, timeCreated);
this.timeCreated = timeCreated;
}
/* (non-Javadoc)
* @see uk.ac.ox.cs.pdq.planner.linear.explorer.node.metadata.Metadata#getParent()
*/
public SearchNode getParent() {
return this.parent;
}
/* (non-Javadoc)
* @see uk.ac.ox.cs.pdq.planner.linear.explorer.node.metadata.Metadata#getTimeCreated()
*/
public double getTimeCreated() {
return this.timeCreated;
}
}
| 25.565217
| 114
| 0.70068
|
fc27fefe301a1dbbf47bb5a4e4c87e3ca2c60523
| 1,573
|
package com.sdyx.report.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* 数据库配置信息对象 report_database
*
* @author easy-report
*/
@Data
@NoArgsConstructor
@Accessors(chain = true)
@TableName("report_database")
public class ReportDatabase implements Serializable {
private static final long serialVersionUID = 1L;
/**
* ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 数据源名称
*/
private String name;
/**
* 连接url
*/
private String jdbcUrl;
/**
* 数据源登录用户名
*/
private String user;
/**
* 数据源登录密码
*/
private String password;
/**
* 数据源配置选项(JSON格式）
*/
private String options;
/**
* 数据库类型
*/
private String dataType;
/**
* 连接池类型
*/
private String poolType;
/**
* 说明备注
*/
private String comment;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
@JsonFormat(pattern = "yyyy-MM-dd")
private Date createTime;
/**
* 创建人
*/
@TableField(fill = FieldFill.INSERT)
private String createBy;
/**
* 更新时间
*/
@TableField(fill = FieldFill.UPDATE)
@JsonFormat(pattern = "yyyy-MM-dd")
private Date updateTime;
/**
* 更新人
*/
@TableField(fill = FieldFill.UPDATE)
private String updateBy;
}
| 16.216495
| 53
| 0.594406
|
a9e762421ec5ec0b4adf146dadb50d169e3c0dc8
| 13,793
|
/*
* Copyright 2015-2017 OpenCB
*
* 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.opencb.opencga.storage.hadoop.variant.converters;
import com.google.common.base.Throwables;
import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.opencb.biodata.models.variant.StudyEntry;
import org.opencb.biodata.models.variant.Variant;
import org.opencb.biodata.models.variant.avro.VariantAnnotation;
import org.opencb.biodata.models.variant.avro.VariantType;
import org.opencb.biodata.models.variant.metadata.VariantFileHeader;
import org.opencb.biodata.models.variant.metadata.VariantFileHeaderComplexLine;
import org.opencb.biodata.tools.Converter;
import org.opencb.biodata.tools.variant.merge.VariantMerger;
import org.opencb.commons.datastore.core.ObjectMap;
import org.opencb.opencga.storage.core.metadata.VariantStorageMetadataManager;
import org.opencb.opencga.storage.core.metadata.models.StudyMetadata;
import org.opencb.opencga.storage.core.variant.VariantStorageOptions;
import org.opencb.opencga.storage.core.variant.adaptors.VariantField;
import org.opencb.opencga.storage.core.variant.adaptors.VariantQueryFields;
import org.opencb.opencga.storage.core.variant.adaptors.VariantQueryParam;
import org.opencb.opencga.storage.hadoop.variant.GenomeHelper;
import org.opencb.opencga.storage.hadoop.variant.adaptors.phoenix.VariantPhoenixHelper;
import org.opencb.opencga.storage.hadoop.variant.converters.annotation.HBaseToVariantAnnotationConverter;
import org.opencb.opencga.storage.hadoop.variant.converters.stats.HBaseToVariantStatsConverter;
import org.opencb.opencga.storage.hadoop.variant.converters.study.HBaseToStudyEntryConverter;
import org.opencb.opencga.storage.hadoop.variant.metadata.HBaseVariantStorageMetadataDBAdaptorFactory;
import org.opencb.opencga.storage.hadoop.variant.mr.VariantTableHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;
import static org.opencb.opencga.storage.core.variant.VariantStorageOptions.SEARCH_INDEX_LAST_TIMESTAMP;
import static org.opencb.opencga.storage.hadoop.variant.adaptors.phoenix.VariantPhoenixKeyFactory.extractVariantFromResultSet;
import static org.opencb.opencga.storage.hadoop.variant.adaptors.phoenix.VariantPhoenixKeyFactory.extractVariantFromVariantRowKey;
/**
* Created on 20/11/15.
*
* @author Jacobo Coll <jacobo167@gmail.com>
*/
public abstract class HBaseToVariantConverter<T> implements Converter<T, Variant> {
public static final String MUTABLE_SAMPLES_POSITION = "mutableSamplesPosition";
public static final String STUDY_NAME_AS_STUDY_ID = "studyNameAsStudyId";
public static final String SIMPLE_GENOTYPES = "simpleGenotypes";
protected final HBaseToVariantAnnotationConverter annotationConverter;
protected final HBaseToStudyEntryConverter studyEntryConverter;
protected final GenomeHelper genomeHelper;
protected final Logger logger = LoggerFactory.getLogger(HBaseToVariantConverter.class);
protected static boolean failOnWrongVariants = false; //FIXME
protected boolean failOnEmptyVariants = false;
protected VariantQueryFields selectVariantElements;
public HBaseToVariantConverter(VariantTableHelper variantTableHelper) throws IOException {
this(variantTableHelper, new VariantStorageMetadataManager(new HBaseVariantStorageMetadataDBAdaptorFactory(variantTableHelper)));
}
public HBaseToVariantConverter(GenomeHelper genomeHelper, VariantStorageMetadataManager scm) {
this.genomeHelper = genomeHelper;
long ts = scm.getProjectMetadata().getAttributes().getLong(SEARCH_INDEX_LAST_TIMESTAMP.key());
this.annotationConverter = new HBaseToVariantAnnotationConverter(genomeHelper, ts)
.setAnnotationIds(scm.getProjectMetadata().getAnnotation());
HBaseToVariantStatsConverter statsConverter = new HBaseToVariantStatsConverter(genomeHelper);
this.studyEntryConverter = new HBaseToStudyEntryConverter(GenomeHelper.COLUMN_FAMILY_BYTES, scm, statsConverter);
}
/**
* Get fixed format for the VARCHAR ARRAY sample columns.
* @param attributes study attributes
* @return List of fixed formats
*/
public static List<String> getFixedFormat(ObjectMap attributes) {
List<String> format;
List<String> extraFields = attributes.getAsStringList(VariantStorageOptions.EXTRA_FORMAT_FIELDS.key());
if (extraFields.isEmpty()) {
extraFields = Collections.singletonList(VariantMerger.GENOTYPE_FILTER_KEY);
}
boolean excludeGenotypes = attributes
.getBoolean(VariantStorageOptions.EXCLUDE_GENOTYPES.key(), VariantStorageOptions.EXCLUDE_GENOTYPES.defaultValue());
if (excludeGenotypes) {
format = extraFields;
} else {
format = new ArrayList<>(1 + extraFields.size());
format.add(VariantMerger.GT_KEY);
format.addAll(extraFields);
}
return format;
}
public static List<String> getFixedAttributes(StudyMetadata studyMetadata) {
return getFixedAttributes(studyMetadata.getVariantHeader());
}
public static List<String> getFixedAttributes(VariantFileHeader variantHeader) {
return variantHeader
.getComplexLines()
.stream()
.filter(line -> line.getKey().equalsIgnoreCase("INFO"))
.map(VariantFileHeaderComplexLine::getId)
.collect(Collectors.toList());
}
public HBaseToVariantConverter<T> setIncludeFields(Set<VariantField> fields) {
annotationConverter.setIncludeFields(fields);
return this;
}
public HBaseToVariantConverter<T> setIncludeIndexStatus(boolean includeIndexStatus) {
annotationConverter.setIncludeIndexStatus(includeIndexStatus);
return this;
}
public HBaseToVariantConverter<T> setStudyNameAsStudyId(boolean studyNameAsStudyId) {
studyEntryConverter.setStudyNameAsStudyId(studyNameAsStudyId);
return this;
}
public HBaseToVariantConverter<T> setMutableSamplesPosition(boolean mutableSamplesPosition) {
studyEntryConverter.setMutableSamplesPosition(mutableSamplesPosition);
return this;
}
public HBaseToVariantConverter<T> setFailOnEmptyVariants(boolean failOnEmptyVariants) {
studyEntryConverter.setFailOnWrongVariants(failOnEmptyVariants);
return this;
}
public HBaseToVariantConverter<T> setSimpleGenotypes(boolean simpleGenotypes) {
studyEntryConverter.setSimpleGenotypes(simpleGenotypes);
return this;
}
public HBaseToVariantConverter<T> setUnknownGenotype(String unknownGenotype) {
studyEntryConverter.setUnknownGenotype(unknownGenotype);
return this;
}
public HBaseToVariantConverter<T> setSelectVariantElements(VariantQueryFields selectVariantElements) {
this.selectVariantElements = selectVariantElements;
studyEntryConverter.setSelectVariantElements(selectVariantElements);
annotationConverter.setIncludeFields(selectVariantElements.getFields());
return this;
}
public static boolean isFailOnWrongVariants() {
return failOnWrongVariants;
}
public static void setFailOnWrongVariants(boolean b) {
failOnWrongVariants = b;
}
/**
* Format of the converted variants. Discard other values.
* @see org.opencb.opencga.storage.core.variant.adaptors.VariantQueryUtils#getIncludeFormats
* @param formats Formats for converted variants
* @return this
*/
public HBaseToVariantConverter<T> setFormats(List<String> formats) {
studyEntryConverter.setFormats(formats);
return this;
}
public static HBaseToVariantConverter<Result> fromResult(VariantTableHelper helper) throws IOException {
return new ResultToVariantConverter(helper);
}
public static HBaseToVariantConverter<Result> fromResult(GenomeHelper genomeHelper, VariantStorageMetadataManager scm) {
return new ResultToVariantConverter(genomeHelper, scm);
}
public static HBaseToVariantConverter<ResultSet> fromResultSet(VariantTableHelper helper) throws IOException {
return new ResultSetToVariantConverter(helper);
}
public static HBaseToVariantConverter<ResultSet> fromResultSet(GenomeHelper genomeHelper, VariantStorageMetadataManager scm) {
return new ResultSetToVariantConverter(genomeHelper, scm);
}
protected Variant convert(Variant variant, Map<Integer, StudyEntry> studies,
VariantAnnotation annotation) {
for (StudyEntry studyEntry : studies.values()) {
variant.addStudyEntry(studyEntry);
}
variant.setAnnotation(annotation);
if (annotation != null && StringUtils.isNotEmpty(annotation.getId())) {
variant.setId(annotation.getId());
} else {
variant.setId(variant.toString());
}
if (failOnEmptyVariants && variant.getStudies().isEmpty()) {
throw new IllegalStateException("No Studies registered for variant!!! " + variant);
}
return variant;
}
private void wrongVariant(String message) {
if (failOnWrongVariants) {
throw new IllegalStateException(message);
} else {
logger.warn(message);
}
}
public HBaseToVariantConverter<T> configure(Configuration configuration) {
if (StringUtils.isNotEmpty(configuration.get(MUTABLE_SAMPLES_POSITION))) {
setMutableSamplesPosition(configuration.getBoolean(MUTABLE_SAMPLES_POSITION, true));
}
if (StringUtils.isNotEmpty(configuration.get(STUDY_NAME_AS_STUDY_ID))) {
setStudyNameAsStudyId(configuration.getBoolean(STUDY_NAME_AS_STUDY_ID, false));
}
if (StringUtils.isNotEmpty(configuration.get(SIMPLE_GENOTYPES))) {
setSimpleGenotypes(configuration.getBoolean(SIMPLE_GENOTYPES, false));
}
setUnknownGenotype(configuration.get(VariantQueryParam.UNKNOWN_GENOTYPE.key()));
// .setSelectVariantElements(select)
// .setFormats(formats)
return this;
}
private static class ResultSetToVariantConverter extends HBaseToVariantConverter<ResultSet> {
ResultSetToVariantConverter(VariantTableHelper helper) throws IOException {
super(helper);
}
ResultSetToVariantConverter(GenomeHelper genomeHelper, VariantStorageMetadataManager scm) {
super(genomeHelper, scm);
}
@Override
public Variant convert(ResultSet resultSet) {
Variant variant = extractVariantFromResultSet(resultSet);
try {
String type = resultSet.getString(VariantPhoenixHelper.VariantColumn.TYPE.column());
if (StringUtils.isNotBlank(type)) {
variant.setType(VariantType.valueOf(type));
}
VariantAnnotation annotation = annotationConverter.convert(resultSet);
Map<Integer, StudyEntry> samplesData = studyEntryConverter.convert(resultSet);
return convert(variant, samplesData, annotation);
} catch (RuntimeException | SQLException e) {
logger.error("Fail to parse variant: " + variant);
throw Throwables.propagate(e);
}
}
}
private static class ResultToVariantConverter extends HBaseToVariantConverter<Result> {
ResultToVariantConverter(VariantTableHelper helper) throws IOException {
super(helper);
}
ResultToVariantConverter(GenomeHelper genomeHelper, VariantStorageMetadataManager scm) {
super(genomeHelper, scm);
}
@Override
public Variant convert(Result result) {
Variant variant = extractVariantFromVariantRowKey(result.getRow());
try {
Cell cell = result.getColumnLatestCell(GenomeHelper.COLUMN_FAMILY_BYTES, VariantPhoenixHelper.VariantColumn.TYPE.bytes());
if (cell != null && cell.getValueLength() > 0) {
String string = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
variant.setType(VariantType.valueOf(string));
}
VariantAnnotation annotation = annotationConverter.convert(result);
Map<Integer, StudyEntry> studies;
if (selectVariantElements != null && selectVariantElements.getStudies().isEmpty()) {
studies = Collections.emptyMap();
} else {
studies = studyEntryConverter.convert(result);
}
return convert(variant, studies, annotation);
} catch (RuntimeException e) {
throw new IllegalStateException("Fail to parse variant: " + variant, e);
}
}
}
}
| 43.787302
| 138
| 0.723338
|
f9a3130a6143014532f0e7327ead940dd50503e6
| 793
|
package club.zhcs.agent.ext.beetl;
import org.beetl.core.Context;
import org.beetl.core.Function;
import org.nutz.lang.Lang;
import org.nutz.mvc.Mvcs;
import club.zhcs.agent.Agent.SessionKeys;
/**
*
* @author kerbores
*
* @email kerbores@gmail.com
*
*/
public class LoginUserFun implements Function {
/*
* (non-Javadoc)
*
* @see org.beetl.core.Function#call(java.lang.Object[],
* org.beetl.core.Context)
*/
@Override
public Object call(Object[] paras, Context ctx) {
if (paras!=null && paras.length > 0) {
String key = paras[0].toString();
Object obj = Mvcs.getReq().getSession().getAttribute(SessionKeys.USER_KEY);
return obj == null ? null : Lang.obj2nutmap(obj).get(key);
}
return Mvcs.getReq().getSession().getAttribute(SessionKeys.USER_KEY);
}
}
| 22.027778
| 78
| 0.692308
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.