text stringlengths 10 2.72M |
|---|
package m3103.tp1;
/*
* This file is licensed 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.
*/
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
/**
* SDD Seance TP 1 : quelques tests pour les tris de la séance
*
* @author <a href="mailto:Frederic.Guyomarch@univ-lille1.fr">Frédéric Guyomarch</a>
* IUT-A, Universite de Lille, Sciences et Technologies
*/
public class SortTest {
final int MIN = 8;
final int MAX = 99;
final int [] SORTED = {8,11,17,22,25,34,47,52,69,98};
int [] unSorted = {22,11,8,17,47,98,25,34,69,52};
@Test
public void testGenerateRdmIntArray() {
int [] rdmTab = Sort.generateRdmIntArray(100,MIN,MAX);
int i = 0;
boolean well = true;
while(i<rdmTab.length&&well){
if(rdmTab[i] < MIN || rdmTab[i] > MAX)
well = false;
i++;
}
assertTrue(well);
}
@Before
public void setUp() {
unSorted = new int[]{22,11,8,17,47,98,25,34,69,52};
}
@Test
public void testSwap() {
int [] before = {8,11,17,22,25,34,47,52,69,98};
int [] after = {8,69,17,22,25,34,47,52,11,98};
Sort.swap(before, 1, 8);
assertArrayEquals(before, after);
}
@Test
public void testBubbleSort() {
Sort.bubbleSort(unSorted);
assertArrayEquals(SORTED, unSorted);
}
@Test
public void testInsertSort() {
Sort.insertSort(unSorted);
assertArrayEquals(SORTED, unSorted);
}
@Test
public void testSelectSort() {
Sort.selectSort(unSorted);
assertArrayEquals(SORTED, unSorted);
}
/*@Test
public void testfuseTab() {
int [] tabA = {8,11,47,98};
int [] tabB = {17,22,25,34,52,69};
int [] tabOut = new int[tabA.length+tabB.length];
Sort.fuseTab(tabA, tabB, tabOut);
assertArrayEquals(tabOut, SORTED);
}*/
}
|
package tech.hobbs.mallparkingmanagementsystem.service;
import tech.hobbs.mallparkingmanagementsystem.entities.Section;
import tech.hobbs.mallparkingmanagementsystem.service.dtos.CreateSectionRequest;
public interface SectionService {
Section createSection(CreateSectionRequest createSectionRequest);
Section updateSection(Long id, CreateSectionRequest createSectionRequest);
}
|
package com.example.demo.services;
import com.example.demo.exceptions.HttpResponseService;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.experimental.SuperBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BaseService {
@Autowired
protected HttpResponseService httpResponseService;
}
|
package com.example.appBack.Tablas.Student.infrastructure.controller;
import com.example.appBack.Tablas.Student.application.port.UpdateStudentPort;
import com.example.appBack.Tablas.Student.domain.Student;
import com.example.appBack.Tablas.Student.infrastructure.controller.dto.Input.StudentInputDTO;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
@Slf4j
@AllArgsConstructor
@RequestMapping("/estudiante")
@CrossOrigin("*")
@Api(tags= "estudiante")
@RestController
public class UpdateStudentController {
private UpdateStudentPort updateStudentPort;
@PutMapping("/{id}")
public Student updateStudent(@PathVariable String id, @RequestBody StudentInputDTO studentInputDTO) throws Exception
{
Student student = studentInputDTO.InputToDTO();
student.setId(id);
return updateStudentPort.update(student);
}
}
|
package gov.samhsa.c2s.pcm.service;
import gov.samhsa.c2s.pcm.config.PcmProperties;
import gov.samhsa.c2s.pcm.domain.Patient;
import gov.samhsa.c2s.pcm.domain.PatientRepository;
import gov.samhsa.c2s.pcm.domain.Provider;
import gov.samhsa.c2s.pcm.domain.ProviderRepository;
import gov.samhsa.c2s.pcm.domain.valueobject.Identifier;
import gov.samhsa.c2s.pcm.infrastructure.PlsService;
import gov.samhsa.c2s.pcm.infrastructure.dto.FlattenedSmallProviderDto;
import gov.samhsa.c2s.pcm.service.dto.AbstractProviderDto;
import gov.samhsa.c2s.pcm.service.dto.IdentifierDto;
import gov.samhsa.c2s.pcm.service.dto.OrganizationDto;
import gov.samhsa.c2s.pcm.service.dto.PractitionerDto;
import gov.samhsa.c2s.pcm.service.exception.InvalidProviderTypeException;
import gov.samhsa.c2s.pcm.service.exception.PatientOrProviderNotFoundException;
import gov.samhsa.c2s.pcm.service.exception.PatientProviderNotFoundException;
import gov.samhsa.c2s.pcm.service.exception.ProviderIsAlreadyInUseException;
import lombok.extern.slf4j.Slf4j;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
@Service
@Slf4j
public class ProviderServiceImpl implements ProviderService {
@Autowired
private PcmProperties pcmProperties;
@Autowired
private ProviderRepository providerRepository;
@Autowired
private PatientRepository patientRepository;
@Autowired
private PlsService plsService;
@Autowired
private ModelMapper modelMapper;
// TODO: refactor this static methods, so ConsentServiceImpl won't need to directly call these. The 'deletable' boolean can be potentially calculated by the Provider, Organization, Practitioner domain entities.
public static boolean isProviderInUse(Set<Identifier> providerIdentifiersWithConsents, Provider provider) {
return providerIdentifiersWithConsents.contains(provider.getIdentifier());
}
// TODO: refactor this static methods, so ConsentServiceImpl won't need to directly call these. The 'deletable' boolean can be potentially calculated by the Provider, Organization, Practitioner domain entities.
public static boolean isProviderInUse(Set<Identifier> providerIdentifiersWithConsents, Set<IdentifierDto> identifiers) {
return providerIdentifiersWithConsents.stream()
.anyMatch(identifier -> identifiers.stream()
.anyMatch(dto -> identifier.getSystem().equals(dto.getSystem()) && identifier.getValue().equals(dto.getValue())));
}
// TODO: refactor this static methods, so ConsentServiceImpl won't need to directly call these. The 'deletable' boolean can be potentially calculated by the Provider, Organization, Practitioner domain entities.
public static Set<Identifier> getProviderIdentifiersWithConsents(Patient patient) {
return patient.getConsents().stream()
.flatMap(consent -> Stream.concat(
consent.getFromProviders().stream().map(Provider::getIdentifier),
consent.getToProviders().stream().map(Provider::getIdentifier)))
.collect(toSet());
}
@Override
@Transactional
public void saveProviders(String patientId, Set<IdentifierDto> providerIdentifierDtos) {
// Assert provider identifier systems
providerIdentifierDtos.stream()
.map(IdentifierDto::getSystem)
.forEach(system -> Assert.isTrue(pcmProperties.getSupportedProviderSystems().contains(system), "Invalid Provider System"));
// Assert provider identifier values
providerIdentifierDtos.stream()
.map(identifier -> {
final FlattenedSmallProviderDto flattenedSmallProvider = plsService.getFlattenedSmallProvider(identifier.getValue(), PlsService.Projection.FLATTEN_SMALL_PROVIDER);
flattenedSmallProvider.setSystem(identifier.getSystem());
return flattenedSmallProvider;
})
.forEach(flattenedSmallProvider -> Assert.notNull(flattenedSmallProvider, "Invalid Provider Selection"));
final Patient patient = patientRepository.saveAndGet(patientId);
// Add new providers to PCM
final List<Provider> providersToAdd = providerIdentifierDtos.stream()
.filter(identifier -> providerRepository.notExistsByIdentifierSystemAndIdentifierValue(identifier.getSystem(), identifier.getValue()))
.map(identifier -> Provider.builder()
.identifier(Identifier.builder()
.value(identifier.getValue())
.system(identifier.getSystem())
.build())
.build())
.collect(toList());
providerRepository.save(providersToAdd);
// Add new providers to Patient
final List<Provider> providersToAddToPatient = providerIdentifierDtos.stream()
.map(identifier -> providerRepository.findOneByIdentifierSystemAndIdentifierValue(identifier.getSystem(), identifier.getValue()))
.filter(Optional::isPresent)
.map(Optional::get)
.filter(provider -> patientRepository.notExistsByIdAndProvidersId(patientId, provider.getId()))
.collect(toList());
patient.getProviders().addAll(providersToAddToPatient);
patientRepository.save(patient);
}
@Override
@Transactional
public List<AbstractProviderDto> getProviders(String patientId) {
final Patient patient = patientRepository.saveAndGet(patientId);
final Set<Identifier> providerIdentifiersWithConsents = getProviderIdentifiersWithConsents(patient);
return patient.getProviders().stream()
.map(provider -> {
final FlattenedSmallProviderDto flattenedSmallProvider = plsService.getFlattenedSmallProvider(provider.getIdentifier().getValue(), PlsService.Projection.FLATTEN_SMALL_PROVIDER);
flattenedSmallProvider.setId(provider.getId());
flattenedSmallProvider.setSystem(provider.getIdentifier().getSystem());
flattenedSmallProvider.setDeletable(!isProviderInUse(providerIdentifiersWithConsents, provider));
return flattenedSmallProvider;
})
.sorted(comparing(FlattenedSmallProviderDto::getId))
.map(flattenedSmallProviderDto -> Optional.of(flattenedSmallProviderDto)
.filter(providerDto -> PlsService.ProviderType.INDIVIDUAL.equalsIgnoreCase(providerDto.getEntityTypeDisplayName()))
.map(providerDto -> modelMapper.map(providerDto, PractitionerDto.class))
.map(AbstractProviderDto.class::cast)
.orElseGet(() -> Optional.of(flattenedSmallProviderDto)
.filter(providerDto -> PlsService.ProviderType.ORGANIZATION.equalsIgnoreCase(providerDto.getEntityTypeDisplayName()))
.map(providerDto -> modelMapper.map(providerDto, OrganizationDto.class))
.orElseThrow(InvalidProviderTypeException::new)))
.collect(toList());
}
@Override
public void deleteProvider(String patientId, Long providerId) {
final Patient patient = patientRepository
.findOneByIdAndProvidersId(patientId, providerId)
.orElseThrow(PatientOrProviderNotFoundException::new);
final Provider provider = providerRepository.findOneById(providerId).orElseThrow(PatientProviderNotFoundException::new);
final Set<Identifier> providerIdentifiersWithConsents = getProviderIdentifiersWithConsents(patient);
if (isProviderInUse(providerIdentifiersWithConsents, provider)) {
throw new ProviderIsAlreadyInUseException();
} else {
patient.getProviders().remove(provider);
patientRepository.save(patient);
}
}
}
|
package com.ebay.lightning.client;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import com.ebay.lightning.client.caller.EmbeddedAPICaller;
import com.ebay.lightning.client.caller.ServiceCaller;
import com.ebay.lightning.core.beans.ReservationReceipt;
import com.ebay.lightning.core.beans.SystemStatus;
import com.ebay.lightning.core.config.SystemConfig;
import com.ebay.lightning.core.services.TaskExecutionService;
import com.ebay.lightning.core.store.LightningRequestReport;
public class EmbeddedAPICallerTest {
private ServiceCaller apiCaller;
private TaskExecutionService service;
@Before
public void setup() {
service = Mockito.mock(TaskExecutionService.class);
apiCaller = new EmbeddedAPICaller(service);
}
@Test
public void testReserve() throws Exception {
ReservationReceipt successReserveResponse = new ReservationReceipt(ReservationReceipt.State.ACCEPTED, "youGotIt", 1000);
Mockito.when(service.reserve(1000)).thenReturn(successReserveResponse);
ReservationReceipt resservationReciept = apiCaller.reserve(1000, "embeddedCoreService");
Assert.assertEquals("youGotIt", resservationReciept.getId());
Assert.assertEquals(ReservationReceipt.State.ACCEPTED, resservationReciept.getState());
ReservationReceipt failedReserveResponse = new ReservationReceipt(ReservationReceipt.State.DENIED, "youGotRejected", 10000000);
Mockito.when(service.reserve(10000000)).thenReturn(failedReserveResponse);
ReservationReceipt resp = apiCaller.reserve(10000000, "embeddedCoreService");
Assert.assertEquals("youGotRejected", resp.getId());
Assert.assertEquals(ReservationReceipt.State.DENIED, resp.getState());
}
@Test(expected=RuntimeException.class)
public void testReserveException() throws Exception {
Mockito.when(service.reserve(10000000)).thenThrow(new RuntimeException("Error Calling service: "));
apiCaller.reserve(10000000, "embeddedCoreService");
}
@Test
public void getAuditReport() throws Exception {
List<LightningRequestReport> expectedReqs = new ArrayList<LightningRequestReport>();
LightningRequestReport expectedReq = new LightningRequestReport();
expectedReqs.add(expectedReq);
Mockito.when(service.getAuditReports("1000")).thenReturn(expectedReqs);
List<LightningRequestReport> actualReqs = apiCaller.getAuditSummary("embeddedCoreService","1000");
Assert.assertNotNull(actualReqs);
Assert.assertEquals(1,actualReqs.size());
}
@Test(expected=RuntimeException.class)
public void getAuditReportException() throws Exception {
Mockito.when(service.getAuditReports("1000")).thenThrow(new RuntimeException("Error Calling service: "));
apiCaller.getAuditSummary("embeddedCoreService", "1000");
}
@Test
public void getSystemConfig() throws Exception {
SystemConfig expectedConfig = new SystemConfig();
SystemConfig resultConfig = new SystemConfig();
Mockito.when(service.getSystemConfig()).thenReturn(expectedConfig);
resultConfig = apiCaller.getSystemConfig("embeddedCoreService");
Assert.assertNotNull(resultConfig);
}
@Test(expected=RuntimeException.class)
public void getSystemConfigException() throws Exception {
Mockito.when(service.getSystemConfig()).thenThrow(new RuntimeException("Error Calling service: "));
apiCaller.getSystemConfig("embeddedCoreService");
}
@Test
public void testgetLightningStats() throws Exception {
SystemStatus resultStats;
SystemStatus expectedStats = new SystemStatus();
Mockito.when(service.getLightningStats()).thenReturn(expectedStats);
resultStats = apiCaller.getLightningStats("embeddedCoreService");
Assert.assertNotNull(resultStats);
}
}
|
package LC0_200.LC100_150;
import java.util.HashSet;
import java.util.List;
public class LC139_Word_Break {
public boolean wordBreak(String s, List<String> wordDict) {
boolean[] dp = new boolean[s.length() + 1];
dp[0] = true;
for (int i = 1; i <= s.length(); ++i) {
for (String str : wordDict) {
if (i >= str.length() && str.equals(s.substring(i - str.length(), i)))
dp[i] = dp[i - str.length()] || dp[i];
}
}
return dp[s.length()];
}
}
|
package com.tt.miniapphost.util;
import android.content.Context;
import android.content.res.AssetManager;
import java.lang.ref.WeakReference;
import java.util.LinkedHashSet;
public class DynamicAppAssetsCompat {
static DynamicsAssetCompat sDynamicActivityAssetsCompat = new DynamicsAssetCompat();
static DynamicsAssetCompat sDynamicAppAssetsCompat = new DynamicsAssetCompat();
public static void ensureDynamicFeatureAssets(Context paramContext) {
if (paramContext == null)
return;
ensureDynamicFeatureAssets(paramContext, paramContext.getAssets());
}
public static void ensureDynamicFeatureAssets(Context paramContext, AssetManager paramAssetManager) {
if (!AppbrandUtil.isAppBundleEnable())
return;
if (paramContext == null)
return;
if (paramAssetManager == null)
return;
if (paramContext instanceof android.app.Activity) {
sDynamicActivityAssetsCompat.ensureAssets(paramContext, paramAssetManager);
return;
}
sDynamicAppAssetsCompat.ensureAssets(paramContext, paramAssetManager);
}
static class DynamicsAssetCompat {
private LinkedHashSet<Integer> injectedAssetHashcodeSet = new LinkedHashSet<Integer>();
private volatile WeakReference<AssetManager> lastInjectedAssetsRef;
public void ensureAssets(Context param1Context, AssetManager param1AssetManager) {
// Byte code:
// 0: aload_0
// 1: getfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 4: ifnull -> 19
// 7: aload_0
// 8: getfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 11: invokevirtual get : ()Ljava/lang/Object;
// 14: aload_2
// 15: if_acmpne -> 19
// 18: return
// 19: aload_0
// 20: monitorenter
// 21: aload_0
// 22: getfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 25: ifnull -> 42
// 28: aload_0
// 29: getfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 32: invokevirtual get : ()Ljava/lang/Object;
// 35: aload_2
// 36: if_acmpne -> 42
// 39: aload_0
// 40: monitorexit
// 41: return
// 42: aload_0
// 43: new java/lang/ref/WeakReference
// 46: dup
// 47: aload_2
// 48: invokespecial <init> : (Ljava/lang/Object;)V
// 51: putfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 54: aload_2
// 55: invokestatic identityHashCode : (Ljava/lang/Object;)I
// 58: istore_3
// 59: aload_0
// 60: getfield injectedAssetHashcodeSet : Ljava/util/LinkedHashSet;
// 63: iload_3
// 64: invokestatic valueOf : (I)Ljava/lang/Integer;
// 67: invokevirtual contains : (Ljava/lang/Object;)Z
// 70: istore #4
// 72: iload #4
// 74: ifne -> 114
// 77: invokestatic getInst : ()Lcom/tt/miniapphost/host/HostDependManager;
// 80: aload_1
// 81: invokevirtual doAppBundleSplitInstallAction : (Landroid/content/Context;)Z
// 84: pop
// 85: goto -> 102
// 88: astore_1
// 89: ldc 'DynamicAppAssetsCompat'
// 91: iconst_1
// 92: anewarray java/lang/Object
// 95: dup
// 96: iconst_0
// 97: aload_1
// 98: aastore
// 99: invokestatic e : (Ljava/lang/String;[Ljava/lang/Object;)V
// 102: aload_0
// 103: getfield injectedAssetHashcodeSet : Ljava/util/LinkedHashSet;
// 106: iload_3
// 107: invokestatic valueOf : (I)Ljava/lang/Integer;
// 110: invokevirtual add : (Ljava/lang/Object;)Z
// 113: pop
// 114: aload_0
// 115: monitorexit
// 116: return
// 117: astore_1
// 118: aload_0
// 119: monitorexit
// 120: aload_1
// 121: athrow
// Exception table:
// from to target type
// 21 41 117 finally
// 42 72 117 finally
// 77 85 88 finally
// 89 102 117 finally
// 102 114 117 finally
// 114 116 117 finally
// 118 120 117 finally
}
public void invalidCaches() {
// Byte code:
// 0: aload_0
// 1: monitorenter
// 2: aload_0
// 3: aconst_null
// 4: putfield lastInjectedAssetsRef : Ljava/lang/ref/WeakReference;
// 7: aload_0
// 8: getfield injectedAssetHashcodeSet : Ljava/util/LinkedHashSet;
// 11: invokevirtual clear : ()V
// 14: aload_0
// 15: monitorexit
// 16: return
// 17: astore_1
// 18: aload_0
// 19: monitorexit
// 20: aload_1
// 21: athrow
// Exception table:
// from to target type
// 2 16 17 finally
// 18 20 17 finally
}
}
}
/* Location: C:\Users\august\Desktop\tik\df_miniapp\classes.jar!\com\tt\miniapphos\\util\DynamicAppAssetsCompat.class
* Java compiler version: 6 (50.0)
* JD-Core Version: 1.1.3
*/ |
package pl.agh.edu.dp.gui;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
import pl.agh.edu.dp.labirynth.Builder.CountingMazeBuilder;
import pl.agh.edu.dp.labirynth.Factory.BombedMazeFactory;
import pl.agh.edu.dp.labirynth.Factory.EnchantedMazeFactory;
import pl.agh.edu.dp.labirynth.Factory.MazeFactory;
import pl.agh.edu.dp.labirynth.MazeGame;
import pl.agh.edu.dp.labirynth.Utils.Vector2d;
import static pl.agh.edu.dp.labirynth.Utils.Direction.*;
public class GameFrame extends Application {
/* ================= Edit here ================= */
static final int PIXEL_SIZE = 64;
static final int WALL_THICKNESS = 2;
private void SetupMaze(Stage stage) throws Exception {
stage.setTitle("MazeGame3000");
/* What factory and builder */
MazeFactory factory = EnchantedMazeFactory.getInstance();
CountingMazeBuilder builder = new CountingMazeBuilder(factory);
mazeGame.createMaze(builder, factory);
/* Starting pos of player */
Vector2d playerPos = new Vector2d(4, 0);
mazeGame.createPlayerAt(playerPos);
}
/* ================= GameFrame ================= */
private MazeGame mazeGame;
@Override
public void start(Stage stage) throws Exception {
this.mazeGame = MazeGame.getInstance();
SetupMaze(stage);
int mapHeight = (mazeGame.getRightLowerPos().y + 1) * PIXEL_SIZE + (mazeGame.getRightLowerPos().y + 2) * WALL_THICKNESS;
int mapWidth = (mazeGame.getRightLowerPos().x + 1) * PIXEL_SIZE + (mazeGame.getRightLowerPos().x + 2) * WALL_THICKNESS;
stage.setResizable(false);
stage.setOnCloseRequest(event -> Platform.exit());
Pane rootNode = new Pane();
GameScene gameScene = new GameScene(rootNode, mapWidth, mapHeight);
refresh(gameScene);
gameScene.setOnKeyPressed(event -> {
try {
switch (event.getCode()) {
case LEFT:
mazeGame.makeMove(West);
break;
case RIGHT:
mazeGame.makeMove(East);
break;
case DOWN:
mazeGame.makeMove(South);
break;
case UP:
mazeGame.makeMove(North);
break;
}
}catch (Exception e){
e.printStackTrace();
}
refresh(gameScene);
});
stage.setScene(gameScene);
stage.show();
}
private void refresh(GameScene gameScene) {
gameScene.genTiles(
mazeGame.getMaze().getRooms(),
mazeGame.getPlayer().getPos(),
mazeGame.getRightLowerPos()
);
}
public void show(String[] args){
launch(args);
}
}
|
package genscript.defaultops;
import genscript.execution.ExecuterTreeElem;
import genscript.parse.IndexReader;
import scriptinterface.execution.ExecutionScope;
import scriptinterface.execution.returnvalues.ExecutionResult;
import scriptinterface.execution.returnvalues.ExecutionReturn;
public class OpQuit<ScopeType extends ExecutionScope, ReaderType extends IndexReader> extends
ExecuterTreeElem<ScopeType, ReaderType> {
@Override
protected ExecutionReturn derivExecute(ScopeType scope) {
return ExecutionResult.QUIT;
}
@Override
public String getName() {
return "quit";
}
}
|
package com.smxknife.mapstruct.demo02;
/**
* @author smxknife
* 2021/3/8
*/
public class Demo02 {
public static void main(String[] args) {
Dto02 dto02 = new Dto02();
dto02.setId(1);
dto02.setName("hello");
dto02.setValue(10.0);
Entity02 entity02 = Mapper02.INSTANCE.toEntity(dto02);
System.out.println(entity02);
}
}
|
package com.tencent.mm.plugin.webview.ui.tools;
import com.tencent.mm.R;
import com.tencent.mm.plugin.webview.ui.tools.widget.input.WebViewInputFooter.b;
class WebViewUI$14 implements b {
final /* synthetic */ WebViewUI pZJ;
WebViewUI$14(WebViewUI webViewUI) {
this.pZJ = webViewUI;
}
public final void aSX() {
WebViewUI.b(this.pZJ, 0);
}
public final void aSY() {
WebViewKeyboardLinearLayout webViewKeyboardLinearLayout = (WebViewKeyboardLinearLayout) this.pZJ.findViewById(R.h.webview_keyboard_ll);
if (webViewKeyboardLinearLayout != null && webViewKeyboardLinearLayout.getKeyBoardHeight() > 0) {
WebViewUI.b(this.pZJ, webViewKeyboardLinearLayout.getKeyBoardHeight());
}
}
}
|
package com.smxknife.ehcache.cache.spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
/**
* @author smxknife
* 2020/6/11
*/
@EnableCaching
@SpringBootApplication
public class AppBoot {
public static void main(String[] args) {
SpringApplication.run(AppBoot.class, args);
}
}
|
package com.tencent.mm.plugin.appbrand.m;
class c$a {
public static c gsM = new c((byte) 0);
}
|
package com.example.shopping.strategy;
public interface GenericStrategy<T> {
T getType();
}
|
package entities.components;
import org.openqa.selenium.By;
public class NoteComponent extends BaseComponent {
public void clickLink(String text) {
getDriver().findElement(By.xpath("//a[text()='" + text + "']")).click();
}
@Override
public boolean isExist() {
return false;
}
@Override
public boolean isExist(int timeout) {
return false;
}
}
|
package com.rishi.baldawa.iq;
/*
You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of
your product fails the quality check. Since each version is developed based on the previous version, all the versions
after a bad version are also bad.
Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following
ones to be bad.
You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find
the first bad version. You should minimize the number of calls to the API.
*/
public class FirstBadVersion {
private final int answer;
public FirstBadVersion(int answer) {
this.answer = answer;
}
private boolean isBadVersion(int version) {
return version >= answer;
}
public int firstBadVersion(int n) {
if(n == 1) {
return 1;
}
long start = 1;
long end = n;
int mid = n / 2;
while (start < end) {
if(isBadVersion(mid)) {
end = mid;
} else {
start = mid + 1;
}
mid = (int)((start + end) / 2);
}
return mid;
}
}
|
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class data {
public static void main(String[] args) {
LocalDate siandien = LocalDate.now();
System.out.println(siandien);
LocalDateTime laikas = LocalDateTime.now();
System.out.println(laikas);
DateTimeFormatter formateris = DateTimeFormatter.ofPattern("yyyy MM dd");
String formatuotaSiandien = siandien.format(formateris);
System.out.println(formatuotaSiandien);
}
}
|
package tutorial_100_java8.java_103_flatMap;
import lombok.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class EmployeeFactory {
List<Employee> employeeList = new ArrayList<>();
public List<EmployeeFactory> poulateEmployee() {
Employee employee1 = new Employee();
employee1.setId(1);
employee1.setName("kshoremaorju");
Address address1 = new Address("line-1", "town-1", "sanantonio", "pincode-1");
Address address2 = new Address("line-2", "town-2", "plano", "75075");
List<Address> addressList1 = Arrays.asList(address1, address2);
employee1.setAddresses(addressList1);
Employee employeee2 = new Employee();
employeee2.setId(2);
employeee2.setName("divyababoju");
Address address3 = new Address("line-1", "town-1", "plano", "75075");
Address address4 = new Address("line-2", "town-2", "plano", "pincode-4");
List<Address> addressList2 = Arrays.asList(address3, address4);
employeee2.setAddresses(addressList2);
employeeList.add(employee1);
employeeList.add(employeee2);
EmployeeFactory employeeFactory = new EmployeeFactory();
employeeFactory.setEmployeeList(employeeList);
List<EmployeeFactory> employeeFactoryList = new ArrayList<>();
employeeFactoryList.add(employeeFactory);
return employeeFactoryList;
}
}
|
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class coneTests{
@Test
public void volume() throws Exception {
cone c = new cone();
//При r = 5 и h = 12 Ожидаемый результат "314"
int actual = (int)Math.round(c.volume(5,12));
float expected = 315;
assertEquals(expected, actual,0);
}
@Test
public void surface_area() {
cone c = new cone();
//При r = 5 и s = 13 Ожидаемый результат "283"
float actual = (int)Math.round(c.surface_area(5,13));
float expected = (float) 283;
assertEquals(expected, actual,0);
}
} |
package com.dais.auto;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.common.Enum.VirtualCapitalOperationInStatusEnum;
import com.common.Enum.VirtualCapitalOperationTypeEnum;
import com.common.utils.HttpUtils;
import com.common.utils.JsonUtils;
import com.common.utils.Utils;
import com.dais.mapper.CommonMapper;
import com.dais.mapper.CommonParamsMapper;
import com.dais.mapper.FvirtualcaptualoperationMapper;
import com.dais.model.*;
import com.dais.service.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 招股金服
* CopyRight : www.zhgtrade.com
* Author : liuyuanbo
* Date： 2018/2/6
*/
@Component
public class RippleRecharge {
@Autowired
private CommonParamsService commonParamsService;
@Autowired
private VirtualCoinService virtualCoinService ;
@Autowired
private FvirtualaddressService fvirtualaddressService;
@Autowired
private FvirtualwalletService fvirtualwalletService;
@Autowired
private FvirtualcaptualoperationService fvirtualcaptualoperationService;
@Autowired
private FvirtualcaptualoperationMapper fvirtualcaptualoperationMapper;
@Autowired
private CaptualOperationSyncService captualOperationSyncService;
@Autowired
private CommonMapper commonMapper;
private static final int step = 500;
private static final int symbol = 6;
@PostConstruct
public void work(){
synchronized (this){
try {
int begin = Integer.parseInt(commonParamsService.getValue("ripple_begin"));
Fvirtualcointype fvirtualcointype = virtualCoinService.selectByPrimaryKey(symbol);
String url = "http://"+fvirtualcointype.getFip()+":"+fvirtualcointype.getFport();
String now = HttpUtils.sendGetRequest(url+"/blockNum",null);
Integer block = Integer.valueOf(now); //当前高度
int time = (block - begin )/step ;
Map params = new HashMap();
for(int i = 0;i<= time;i++){
params.put("min",begin);
begin = begin+step;
params.put("max",begin);
List<Fvirtualaddress> fvirtualaddresses = fvirtualaddressService.listFvirtualAddressBySymbol(symbol);
for (Fvirtualaddress fvirtualaddress : fvirtualaddresses) {
try {
params.put("address",fvirtualaddress.getFadderess());
String result = HttpUtils.sendGetRequest(url+"/getTransactions",params);
JSONArray jsonArray = JSONArray.parseArray(result);
for(int j = 0; j< jsonArray.size();j++){
JSONObject jsonObject = (JSONObject) jsonArray.get(j);
String id = jsonObject.getString("id");
JSONObject specification = (JSONObject)jsonObject.get("specification");
JSONObject source = (JSONObject) specification.get("source");
String fromAddress = source.getString("address");
JSONObject destination = (JSONObject) specification.get("destination");
JSONObject amount = (JSONObject)destination.get("amount");
String toAddress = destination.getString("address");
Integer tag = destination.getIntValue("tag");
String currency = amount.getString("currency");
String value = amount.getString("value");
JSONObject outcome = (JSONObject) jsonObject.get("outcome");
if("XRP".equals(currency) && fvirtualaddress.getFadderess().equals(toAddress)){
List<Fvirtualcaptualoperation> fvirtualcaptualoperations = this.fvirtualcaptualoperationService.selectByTypeAndTradeUniqueNumber(VirtualCapitalOperationTypeEnum.COIN_IN,id+"-"+toAddress);
if(fvirtualcaptualoperations!= null && fvirtualcaptualoperations.size() > 0){
continue;
}
Fvirtualcaptualoperation fvirtualcaptualoperation = new Fvirtualcaptualoperation();
fvirtualcaptualoperation.setFusFid2(fvirtualaddress.getFuid());
fvirtualcaptualoperation.setFamount(Double.valueOf(value));
fvirtualcaptualoperation.setFcreatetime(Utils.getTimestamp());
fvirtualcaptualoperation.setFlastupdatetime(Utils.getTimestamp());
try {
fvirtualcaptualoperation.setFfees(Double.valueOf(outcome.get("fee").toString()));
fvirtualcaptualoperation.setBlockindex(Integer.valueOf(outcome.get("ledgerVersion").toString()));
fvirtualcaptualoperation.setFconfirmations(Integer.valueOf(outcome.get("indexInLedger").toString()));
} catch (Exception e) {
}
fvirtualcaptualoperation.setFstatus(VirtualCapitalOperationInStatusEnum.SUCCESS) ;
fvirtualcaptualoperation.setFtradeuniquenumber(id+"-"+toAddress);
fvirtualcaptualoperation.setRechargeVirtualAddress(toAddress);
fvirtualcaptualoperation.setWithdrawVirtualAddress(fromAddress);
fvirtualcaptualoperation.setFtype(VirtualCapitalOperationTypeEnum.COIN_IN);
fvirtualcaptualoperation.setFviFid2(fvirtualcointype.getFid());
this.fvirtualcaptualoperationMapper.insertSelective(fvirtualcaptualoperation);
this.captualOperationSyncService.insertByParam(fvirtualcaptualoperation,fvirtualcointype);
Fvirtualwallet fvirtualwallet = this.fvirtualwalletService.selectFvirtualwallet(fvirtualaddress.getFuid(), fvirtualcointype.getFid());
if (fvirtualwallet == null){
fvirtualwallet = fvirtualwalletService.insertFvirtualwallet(fvirtualaddress.getFuid(), fvirtualcointype.getFid());
}
String balanceStr = HttpUtils.sendGetRequest(url+"/getBalance",params);
if(!StringUtils.isEmpty(balanceStr)){
JSONArray json = JSONArray.parseArray(balanceStr);
JSONObject temp = (JSONObject) json.get(0);
fvirtualwallet.setFtotal(Double.valueOf(temp.get("value").toString()));
}else {
fvirtualwallet.setFtotal(fvirtualwallet.getFtotal() + Double.valueOf(value));
}
fvirtualwallet.setFlastupdatetime(Utils.getTimestamp());
this.fvirtualwalletService.updateFvirtualwallet(fvirtualwallet);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
commonMapper.update("update common_params set param_value = '"+begin+"' where param_key = 'ripple_begin'");
}catch (Exception e){
e.printStackTrace();
}
}
}
}
|
package extconverter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import javax.xml.bind.TypeConstraintException;
import org.apache.struts2.util.StrutsTypeConverter;
public class DateConverter extends StrutsTypeConverter {
private static SimpleDateFormat[] formatArray = {
new SimpleDateFormat("yyyy-MM-dd"),
new SimpleDateFormat("yyyy年MM月dd日"),
new SimpleDateFormat("yyyy/MM/dd") };
@Override
public Object convertFromString(Map arg0, String[] arg1, Class arg2) {
System.out.println("执行了Date日期格式转换!");
String dateString = arg1[0];
for (int i = 0; i < formatArray.length; i++) {
try {
return formatArray[i].parse(dateString);
} catch (ParseException e) {
e.printStackTrace();
continue;
}
}
throw new TypeConstraintException("日期转换失败");
}
// convertToString()方法仅仅在使用Struts2标签输出时调用
@Override
public String convertToString(Map arg0, Object arg1) {
System.out.println("DateConverter convertToString");
return "在IE中输出："
+ new SimpleDateFormat("yyyy-MM-dd").format((Date) arg1);
}
}
|
package com.cnk.travelogix.core.livesupporti.client;
import com.cnk.travelogix.core.livesupporti.client.dto.OfflineMessage;
import com.cnk.travelogix.core.livesupporti.client.dto.OfflineMessages;
public interface OffLineMessagesRestClient {
public OfflineMessages getAllOffLineMessages(String page);
public OfflineMessage getOffLineMessageById(int id);
}
|
package com.excilys.formation.cdb.persistence.normal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.excilys.formation.cdb.persistence.datasource.ConnectionSQL;
import com.excilys.formation.cdb.core.enumeration.Resultat;
import com.excilys.formation.cdb.core.logging.Logging;
import com.excilys.formation.cdb.binding.mapper.MapperCompany;
import com.excilys.formation.cdb.core.model.Company;
import com.excilys.formation.cdb.persistence.CompanyDao;
@Repository
public class CompanyDaoNormal implements CompanyDao{
private static Logger logger = Logging.getLogger();
ConnectionSQL connectionSQL;
/**
* Constructeur de la classe, en privé pour le singleton.
*/
@Autowired
public CompanyDaoNormal(ConnectionSQL connectionSQL) {
this.connectionSQL = connectionSQL;
}
public ConnectionSQL getConnection() {
return connectionSQL;
}
public void setConnection(ConnectionSQL connectionSQL) {
this.connectionSQL = connectionSQL;
}
/**
* String représentant la requête pour obtenir la liste entière de companies de
* la base de données.
*/
private static final String REQUETELISTECOMPANIES = "SELECT company.id, company.name FROM company";
private static final String REQUETEFINDBYID = "SELECT company.id, company.name FROM company WHERE company.id = ";
/**
* Méthode faisant la requête à la base de données pour avoir la liste de
* companies.
*
* @return un string étant soit un message d'erreur soit la liste de companies.
* @exception SQLException Si problème lorsque la base de données s'occupe de la
* requête.
*/
public List<Company> all(String pOrderBy) {
logger.debug("Start of all from CompanyDaoNormal.");
String orderBy = CompanyDao.modificationOrderBy(pOrderBy);
List<Company> listCompanies = new ArrayList<Company>();
try {
Connection connection = connectionSQL.getConnection();
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(REQUETELISTECOMPANIES + " ORDER BY " + orderBy + ";");
while (resultSet.next()) {
int id = resultSet.getInt("company.id");
String name = resultSet.getString("company.name");
Company company = new Company.CompanyBuilder((long) id).withName(name).build();
listCompanies.add(company);
}
statement.close();
connection.close();
} catch (SQLException e) {
System.out.println("dans except");
logger.error("Problème lors de la requête de la liste de companies à la base de données : "
+ e.getLocalizedMessage());
System.exit(1);
}
logger.debug("End of all from CompanyDaoNormal");
return listCompanies;
}
/**
* Méthode faisant la requête à la base de données pour avoir la liste de
* companies.
*
* @return un string étant soit un message d'erreur soit la liste de companies.
* @exception SQLException Si problème lorsque la base de données s'occupe de la
* requête.
*/
public List<Company> allSearch(String rechercheNom, String pOrderBy) {
String orderBy = CompanyDao.modificationOrderBy(pOrderBy);
List<Company> listCompanies = new ArrayList<Company>();
try {
Connection connection = connectionSQL.getConnection();
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(REQUETELISTECOMPANIES + " WHERE company.name LIKE '%"
+ rechercheNom + "%' ORDER BY " + orderBy + ";");
while (resultSet.next()) {
int id = resultSet.getInt("company.id");
String name = resultSet.getString("company.name");
Company company = new Company.CompanyBuilder((long) id).withName(name).build();
listCompanies.add(company);
}
statement.close();
connection.close();
} catch (SQLException e) {
logger.error("Problème lors de la requête de la liste de companies à la base de données : "
+ e.getLocalizedMessage());
System.exit(1);
}
return listCompanies;
}
/**
* Méthode faisant une requête pour vérifier que la base de données contient la
* company dont l'id est passé en paramètre et retournée ses valeurs.
*
* @param companyId : L'id de la company concernant la requête.
* @return ResultSet contenant les résultats de la requête.
* @exception SQLException Si problème lorsque la base de données s'occupe des
* requêtes.
*/
public Company find(int companyId) throws Exception {
Company company = null;
try {
Connection connection = connectionSQL.getConnection();
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(REQUETEFINDBYID + companyId + ";");
if (resultSet.next()) {
company = MapperCompany.resultSetToCompany(resultSet);
if (company == null) {
throw new Exception("Une company reçue par ResultSet est nulle : findCompanyById");
}
if(resultSet.next()) {
throw new Exception("Le resultSet devant avoir une company en avait plusieurs : findCompanyById");
}
}
statement.close();
connection.close();
} catch (SQLException e) {
throw new Exception(e.getLocalizedMessage() + " : findCompanyById");
} catch (Exception e) {
throw new Exception(e.getLocalizedMessage() + " : findCompanyById");
}
return company;
}
public Resultat delete(int id) {
String requeteRechercheEtDestructionComputers = "DELETE FROM computer WHERE computer.company_id = ?;";
String requeteNombreComputersAvecCompany = "SELECT computer.company_id FROM computer WHERE computer.company_id = ?;";
String requeteRechercheEtDestructionCompany = "DELETE FROM company WHERE company.id = ?";
Connection connection = null;
try {
connection = connectionSQL.getConnection();
connection.setAutoCommit(false);
PreparedStatement statementDebut = connection.prepareStatement(requeteRechercheEtDestructionComputers);
PreparedStatement statementMilieu = connection.prepareStatement(requeteNombreComputersAvecCompany);
PreparedStatement statementFin = connection.prepareStatement(requeteRechercheEtDestructionCompany);
statementDebut.setInt(1, id);
statementDebut.executeUpdate();
statementMilieu.setInt(1, id);
ResultSet resultSet = statementMilieu.executeQuery();
if (resultSet.next()) {
throw new SQLException();
}
statementFin.setInt(1, id);
statementFin.executeUpdate();
} catch (SQLException e) {
System.out.println("Prob e : " + e.getLocalizedMessage());
if (connection != null) {
try {
connection.rollback();
} catch (SQLException e1) {
System.out.println("Prob e1 : " + e.getLocalizedMessage());
}
}
} finally {
try {
if (connection != null) {
connection.commit();
connection.setAutoCommit(true);
connection.close();
}
} catch (SQLException e) {
}
}
return Resultat.REUSSI;
}
public List<Company> some(String orderBy) throws Exception {
// TODO Auto-generated method stub
return null;
}
public List<Company> someSearch(String orderBy, String search) throws Exception {
// TODO Auto-generated method stub
return null;
}
public Resultat modify(Company object) {
// TODO Auto-generated method stub
return null;
}
public Resultat create(Company object) {
// TODO Auto-generated method stub
return null;
}
@Override
public Resultat update(Company company) {
// TODO Auto-generated method stub
return null;
}
}
|
package baekjoon.dp1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test_2748 {
//동적계획법 첫번째 문제
//아무 생각없이 기존의 재귀를 이용한 방식으로 풀었더니 시간 초과가 떴다.
//값을 저장하여 다시 계산하지 않고 가져다 쓰는 메모리제이션을 활용하여 풀어 해결하였다.
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
long[] arr = new long[n+1];
for(int i=0; i<=n; i++) {
arr[i] = -1;
}
arr[0] = 0;
arr[1] = 1;
System.out.println(fibonacci(n, arr));
}
static long fibonacci(int n, long[] arr) {
if(arr[n] == -1) {
arr[n] = fibonacci(n-1, arr) + fibonacci(n-2, arr);
}
return arr[n];
}
}
|
package com.yixin.dsc.dto;
import java.io.Serializable;
/**
* 工作流逆向
* 取消、提回、退回订单
*
* Package : com.yixin.dsc.dto
*
* @author YixinCapital -- wangxulong
* 2018年6月3日 下午9:50:15
*
*/
public class DscReverseFlowForAlixDto implements Serializable{
private static final long serialVersionUID = 7867889412012600645L;
/**
* 动作类型
* 1：取消，2：提回 3：退回 4 拒绝
*/
private String ctype;
/**
* 订单编号
*/
private String applyNo;
/**
* 受理结果code，成功：100000，失败：100001
*/
private String code;
/**
* 处理结果message
*/
private String message;
public String getCtype() {
return ctype;
}
public void setCtype(String ctype) {
this.ctype = ctype;
}
public String getApplyNo() {
return applyNo;
}
public void setApplyNo(String applyNo) {
this.applyNo = applyNo;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
} |
package assemAssist.model.company;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.joda.time.DateTime;
import org.joda.time.Duration;
import org.junit.Before;
import org.junit.Test;
import assemAssist.TestInit;
import assemAssist.model.operations.task.Task;
import assemAssist.model.order.Customer;
import assemAssist.model.order.order.ModifiableOrder;
import assemAssist.model.order.order.Order;
import assemAssist.model.order.vehicleOrder.ModifiableVehicleOrder;
import assemAssist.model.order.vehicleOrder.VehicleOrder;
public class OrderAdministrationTest {
OrderAdministration administration = new OrderAdministration();
static Customer maarten = new Customer("Maarten", "iets lang");
static Customer michael = new Customer("Michael", "Vincken");
@Before
public void initialise() {
}
@Test
public void testisValidCustomer() {
VehicleModel model = TestInit.getVehicleModel();
VehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertTrue(administration.isValidCustomer(maarten));
}
@Test
public void testisValidCustomerNull() {
assertFalse(administration.isValidCustomer(null));
}
@Test
public void testisValidOrder() {
assertTrue(administration.isValidOrder(TestInit.getSingleTaskOrder()));
}
@Test
public void testisValidOrderNull() {
assertFalse(administration.isValidOrder(null));
}
@Test
public void testcontainsOrder() {
Order order = TestInit.getOrder();
administration.addOrder(order);
assertTrue(administration.containsOrder(order));
}
@Test
public void testcontainsOrderNot() {
Order order = TestInit.getOrder();
assertFalse(administration.containsOrder(order));
}
@Test
public void testcontainsOrderNull() {
assertFalse(administration.containsOrder(null));
}
@Test
public void testgetMedianDelayEven() {
List<Long> orders = new ArrayList<Long>();
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(3));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(4));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
Collections.sort(orders);
assertEquals(administration.getMedianDelay().getMillis(),
(long) Math.ceil(((orders.get(1) + orders.get(2)) / 2) / 100.0) * 100);
}
@Test
public void testgetMedianDelayOdd() {
List<Long> orders = new ArrayList<Long>();
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
orders.add(order.getDelay().getMillis());
Collections.sort(orders);
assertEquals((long) administration.getMedianDelay().getMillis(),
(long) (Math.ceil(orders.get(1) / 100.0) * 100));
}
@Test
public void testgetMedianDelay1() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertEquals(1, administration.getActiveOrders(maarten).size());
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
assertEquals(1, administration.getCompletedOrders(maarten).size());
long delay = order.getDelay().getStandardMinutes();
assertEquals(administration.getMedianDelay().getStandardMinutes(), delay);
}
@Test
public void testgetMedianDelayNone() {
assertTrue(administration.getMedianDelay().getStandardMinutes() == 0);
}
@Test
public void testgetMedianDelayNotFinished() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertTrue(administration.getMedianDelay().getStandardMinutes() == 0);
}
@Test
public void testgetCompleted() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
assertTrue(administration.getCompletedOrders(michael).size() == 1);
assertTrue(administration.getCompletedOrders(michael).get(0).isFinished());
}
@Test(expected = IllegalArgumentException.class)
public void testgetCompletedInvalidClient() {
administration.getCompletedOrders(null);
}
@Test
public void testgetActiveOrders() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task task : order.getTasks()) {
task.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertEquals(administration.getActiveOrders(michael).size(), 3);
}
@Test(expected = IllegalArgumentException.class)
public void testgetActiveOrdersInvalidClient() {
administration.getActiveOrders(null);
}
@Test
public void testgetAverageDelay() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
long delay = order.getDelay().getMillis();
model = TestInit.getVehicleModel();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
order.getCompletionDate();
assertTrue(order.isFinished());
delay += order.getDelay().getMillis();
assertEquals(administration.getAverageDelay().getMillis(),
(long) Math.ceil((delay / 2) / 100.0) * 100);
}
@Test
public void testgetAverageDelay1() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime());
order.getCompletionDate();
assertTrue(order.isFinished());
long delay = order.getDelay().getStandardMinutes();
assertTrue(administration.getAverageDelay().getStandardMinutes() == delay);
}
@Test
public void testgetAverageDelayNone() {
assertTrue(administration.getAverageDelay().getStandardMinutes() == 0);
}
@Test
public void testgetAverageDelayNotFinished() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertTrue(administration.getAverageDelay().getStandardMinutes() == 0);
}
@Test
public void testgetActiveOrdersNull() {
assertTrue(administration.getActiveOrders().size() == 0);
}
@Test
public void testgetActive() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task task : order.getTasks()) {
task.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
assertEquals(administration.getActiveOrders().size(), 4);
}
@Test
public void testgetRecentlyProducedCars() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
DateTime date = order.getCompletionDate().withTimeAtStartOfDay();
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
assertEquals(administration.getRecentlyProducedCars().get(1).getValue0(), date);
assertEquals(administration.getRecentlyProducedCars().get(1).getValue1(), (Integer) 1);
date = order.getCompletionDate().withTimeAtStartOfDay();
assertEquals(administration.getRecentlyProducedCars().get(0).getValue0(), date);
assertEquals(administration.getRecentlyProducedCars().get(0).getValue1(), (Integer) 1);
}
@Test
public void testgetRecentProducedCars1() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
DateTime date = order.getCompletionDate().withTimeAtStartOfDay();
assertEquals(administration.getRecentlyProducedCars().get(0).getValue0(), date);
assertEquals(administration.getRecentlyProducedCars().get(0).getValue1(), (Integer) 1);
}
@Test
public void testgetRecentlyProducedCarsNone() {
assertEquals(administration.getRecentlyProducedCars().size(), 0);
}
@Test
public void testgetAverageCarProducedNone() {
assertEquals((int) administration.getAverageCarProduced(), 0);
}
@Test
public void testgetAverageCarProducedCars() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
assertEquals(administration.getAverageCarProduced(), 1.3333333, 0.0001);
}
@Test
public void testgetMedianCarsProduced() {
assertEquals(administration.getMedianCarsProduced(), 0, 0.0001);
}
@Test
public void testgetMedianCarsProducedNone() {
assertEquals(administration.getAverageCarProduced(), 0, 0.001);
}
@Test
public void testgetMedianCarsProducedOdd() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
assertEquals(administration.getMedianCarsProduced(), 1, 0.001);
}
@Test
public void testgetMedianCarsProducedEven() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(1));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
administration.addOrder(order);
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(maarten, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setCompletionDate(new DateTime().plusDays(4));
assertTrue(order.isFinished());
assertEquals(administration.getMedianCarsProduced(), 1.0, 0.000001);
}
@Test
public void testgetMostRecentDelaysNOne() {
assertEquals(administration.getMostRecentDelays().size(), 0);
}
@Test
public void testgetMostRecentDelays1() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(1));
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
assertEquals(administration.getMostRecentDelays().get(0).getValue0(),
order.getCompletionDate());
}
@Test
public void testgetMostRecentDelays() {
VehicleModel model = TestInit.getVehicleModel();
ModifiableVehicleOrder order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(1));
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(2));
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(2));
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(2));
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(2));
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
order = new ModifiableVehicleOrder(michael, model,
TestInit.chooseOptionsForVehicleModel(model));
administration.addOrder(order);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(2));
order.setCompletionDate(new DateTime().plusDays(3));
assertTrue(order.isFinished());
assertEquals(administration.getMostRecentDelays().get(0).getValue0(),
order.getCompletionDate());
}
@Test
public void testaddHistoryOrder() {
ModifiableOrder order = TestInit.getVehicleOrder().getModifiableOrder();
final Duration workedTime = new Duration(10);
for (Task t : order.getTasks()) {
t.getModifiableTask().finish(workedTime);
}
order.setFirstEstDate(new DateTime().plusDays(1));
order.setCompletionDate(new DateTime().plusDays(2));
assertTrue(order.isFinished());
administration.addHistoryOrder(order);
assertTrue(administration.containsOrder(order));
}
@Test(expected = IllegalArgumentException.class)
public void testaddHistoryOrderTrhows() {
ModifiableOrder order = TestInit.getVehicleOrder().getModifiableOrder();
administration.addHistoryOrder(order);
assertTrue(administration.containsOrder(order));
}
}
|
package com.hallauniv.parse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import android.app.Activity;
import android.util.Log;
import android.webkit.WebChromeClient;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.widget.Toast;
public class cmsHTTP {
public WebView webview;
public String mimeType = "text/html";
public String encoding = "UTF-8";
public int REGISTRATION_TIMEOUT = 5 * 1000;
public String TAG = "cmsHTTP";
public Activity act;
public String noData = "죄송합니다.\n네트웍 장애가 있습니다.\n다시 시도해주세요.";
public cmsHTTP() {
}
public cmsHTTP(WebView webviewTmp) {
webview = webviewTmp;
}
public String sendGet(String url) {
String result = null;
HttpResponse resp;
/*
if (act != null)
((owllab) act.getApplication()).startLoading(act);
*/
HttpGet httpGet = new HttpGet(url);
HttpClient httpClient = new DefaultHttpClient();
HttpParams tmpparms = httpClient.getParams();
HttpConnectionParams.setConnectionTimeout(tmpparms,
REGISTRATION_TIMEOUT);
HttpConnectionParams.setSoTimeout(tmpparms, REGISTRATION_TIMEOUT);
ConnManagerParams.setTimeout(tmpparms, REGISTRATION_TIMEOUT);
try {
resp = httpClient.execute(httpGet);
if (resp.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "Successful authentication");
HttpEntity respEntity = resp.getEntity();
if (respEntity != null) {
InputStream instream = respEntity.getContent();
result = convertStreamToString(instream);
instream.close();
}
} else {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "Error Process" + resp.getStatusLine());
}
} catch (final IOException e) {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "IOException when getting authtoken", e);
} finally {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "completing");
}
/*
if (act != null)
((owllab) act.getApplication()).endLoading();
*/
if (result == null) {
Toast.makeText(act, noData, Toast.LENGTH_SHORT).show();
}
return result;
}
// ArrayList<NameValuePair> httpParams = new ArrayList<NameValuePair>();
// httpParams.add(new BasicNameValuePair("a", "?쒓? "));
// httpParams.add(new BasicNameValuePair("b", "?꾩슱而?OWLCOM"));
public String sendPostOnly(String url, ArrayList<NameValuePair> params) {
String result = null;
HttpResponse resp;
HttpEntity entity = null;
try {
entity = new UrlEncodedFormEntity(params, encoding);
} catch (final UnsupportedEncodingException e) {
throw new AssertionError(e);
}
HttpPost httpPost = new HttpPost(url);
httpPost.addHeader(entity.getContentType());
httpPost.setEntity(entity);
Toast.makeText(act, url, 5).show();
Log.v(TAG, entity.getContentType().toString());
HttpClient httpClient = new DefaultHttpClient();
HttpParams tmpparms = httpClient.getParams();
HttpConnectionParams.setConnectionTimeout(tmpparms,
REGISTRATION_TIMEOUT);
HttpConnectionParams.setSoTimeout(tmpparms, REGISTRATION_TIMEOUT);
ConnManagerParams.setTimeout(tmpparms, REGISTRATION_TIMEOUT);
try {
resp = httpClient.execute(httpPost);
if (resp.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "Successful authentication");
HttpEntity respEntity = resp.getEntity();
if (respEntity != null) {
InputStream instream = respEntity.getContent();
result = convertStreamToString(instream);
instream.close();
}
} else {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "Error Process" + resp.getStatusLine());
}
} catch (final IOException e) {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "IOException when getting authtoken", e);
} finally {
if (Log.isLoggable(TAG, Log.VERBOSE))
Log.v(TAG, "completing");
}
if (result == null) {
Toast.makeText(act, noData, Toast.LENGTH_SHORT).show();
}
return result;
}
public String sendPost(String url, ArrayList<NameValuePair> params) {
String result = null;
/*
if (act != null)
((owllab) act.getApplication()).startLoading(act);
*/
result = sendPostOnly(url, params);
/*
if (act != null)
((owllab) act.getApplication()).endLoading();
*/
return result;
}
public void getPost(String url, ArrayList<NameValuePair> params) {
final String furl = url;
final ArrayList<NameValuePair> fparams = params;
Thread t = new Thread() {
public void run() {
try {
String result = sendPostOnly(furl, fparams);
webview.getSettings().setJavaScriptEnabled(true);
webview.getSettings()
.setJavaScriptCanOpenWindowsAutomatically(true);
// webview.getSettings().setPluginsEnabled(true);
webview.getSettings().setPluginState(
WebSettings.PluginState.ON_DEMAND);
webview.getSettings().setSupportMultipleWindows(true);
webview.getSettings().setSupportZoom(true);
webview.getSettings().setBuiltInZoomControls(true);
webview.getSettings().setBlockNetworkImage(false);
webview.getSettings().setLoadsImagesAutomatically(true);
webview.getSettings().setUseWideViewPort(true);
webview.getSettings().setCacheMode(
WebSettings.LOAD_NO_CACHE);
webview.setWebChromeClient(new WebChromeClient());
webview.clearCache(true);
String baseUrl = "http://www.owllab.com/android/";
// String baseUrl = "about:none";
webview.loadDataWithBaseURL(baseUrl, result, mimeType,
encoding, baseUrl);
// webview.loadData(result, mimeType, encoding);
} catch (Exception e) {
Log.d("::Exception::", e.toString());
}
}
};
t.start();
}
public String convertStreamToString(InputStream is) {
StringBuilder sb = new StringBuilder();
String line = null;
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(
is, encoding), 8);
while ((line = reader.readLine()) != null) {
sb.append(line + "\n");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return sb.toString();
}
/*
public void postFile(String url, String filename)
throws ClientProtocolException, IOException {
HttpClient httpclient = new DefaultHttpClient();
httpclient.getParams().setParameter(
CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
HttpPost httppost = new HttpPost(url);
File file = new File(filename);
MultipartEntity mpEntity = new MultipartEntity();
ContentBody cbFile = new FileBody(file, "image/jpeg");
mpEntity.addPart("userfile", cbFile);
httppost.setEntity(mpEntity);
System.out.println("executing request " + httppost.getRequestLine());
HttpResponse response = httpclient.execute(httppost);
HttpEntity resEntity = response.getEntity();
if (resEntity != null) {
System.out.println(EntityUtils.toString(resEntity));
}
if (resEntity != null) {
resEntity.consumeContent();
}
httpclient.getConnectionManager().shutdown();
}
*/
} |
package weather;
public class WeatherObject {
public String city = "";
public String temp = "";
public String precProb = "";
//constructor
public WeatherObject(String city, String temp, String precProb) {
this.city = city;
this.temp = temp;
this.precProb = precProb;
}
}
|
package app0512.graphic;
import java.awt.Graphics;
import java.awt.Image;
import javax.swing.JPanel;
//JPanel을 상속받아서, paint메서드를 재정의 하기 위한 클래스
public class DetailView extends JPanel{
PhotoAlbum photoAlbum;
Image image;
public DetailView(PhotoAlbum photoAlbum) {
this.photoAlbum=photoAlbum;
}
//클릭시마다 넘겨받을 이미지처리
public void setImage(Image image) {
this.image = image;
System.out.println("클릭시 넘어온 이미지는"+image);
}
@Override
public void paint(Graphics g) {
g.drawImage(image, 0, 0, this);
}
}
|
/**
*
*/
/**
* @author 324115906
*
*/
public class Label {
/**
* @param args
*/
private ContestantInformation ci1;
public Label (ContestantInformation ci){
this.ci1 = ci;
}
private String formatName(){
String name = ci1.getlastName() + ", "+ ci1.getfirstName()+ "\n";
return name;
}
private String formatAddress(){
String Address0 = ci1.getstreetAddress() + "\n";
String Address1 = ci1.getcity() +", "+ ci1.getprovince() + "\n";
String Address2 = ci1.getpostalCode()+" ";
return Address0+Address1+Address2;
}
private String formatPhoneNumber(){
String phoneNum = ci1.getphoneNumber();
String phoneFormat = "("+ phoneNum.charAt(0) + phoneNum.charAt(1) + phoneNum.charAt(2)+") "+phoneNum.charAt(3)+phoneNum.charAt(4)+ phoneNum.charAt(5)+"-"+phoneNum.charAt(6)+phoneNum.charAt(7)+phoneNum.charAt(8)+phoneNum.charAt(9) + "\n";
return phoneFormat;
}
public String toString(){
return formatName() + formatAddress()+ formatPhoneNumber();
}
}
|
package com.koreait.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.koreait.dto.ItemDto;
import com.koreait.dto.MemberDto;
import com.koreait.mybatis.config.DBService;
public class MemberDao {
// Field
private SqlSessionFactory factory = null;
// Singleton
private MemberDao() {
factory = DBService.getFactory();
}
private static MemberDao dao = new MemberDao();
public static MemberDao getInstance() {
return dao;
}
public MemberDto getMemberForLogin(MemberDto dto) {
SqlSession sqlSession = factory.openSession();
MemberDto mDto = sqlSession.selectOne("select_by_mId_mPw", dto);
sqlSession.close();
return mDto;
}
public List<ItemDto> getItemList() {
SqlSession sqlSession = factory.openSession();
List<ItemDto> list = sqlSession.selectList("select_list");
sqlSession.close();
return list;
}
public MemberDto getMemberPointReset(String mId) {
SqlSession sqlSession = factory.openSession();
MemberDto mDto = sqlSession.selectOne("select_by_Point_Reset", mId);
sqlSession.close();
return mDto;
}
public int getMemberUpdatePoint(String mId) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.update("updatePoint", mId);
if ( result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public MemberDto getMemberBymEmail(String mEmail) {
SqlSession sqlSession = factory.openSession();
MemberDto mDto = sqlSession.selectOne("select_by_mEmail", mEmail);
sqlSession.close();
return mDto;
}
public MemberDto getMemberBymId(String mId) {
SqlSession sqlSession = factory.openSession();
MemberDto mDto = sqlSession.selectOne("select_by_mId", mId);
sqlSession.close();
return mDto;
}
public int getUpdatemPw(MemberDto dto) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.update("update_mPw", dto);
if ( result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public int getInsertMember(MemberDto dto) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.insert("insert", dto);
if ( result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public int getDeleteMember(String mId) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.delete("leave", mId);
if ( result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public int getUpdateItem(String item) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.update("update_item", item);
if(result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public int getUpdatePointMinus(MemberDto dto) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.update("point_minus", dto);
if(result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
public ItemDto getItem(String item) {
SqlSession sqlSession = factory.openSession();
ItemDto mDto = sqlSession.selectOne("select_item", item);
sqlSession.close();
return mDto;
}
public int getInsertItem(ItemDto dto) {
SqlSession sqlSession = factory.openSession(false);
int result = sqlSession.insert("insert_item", dto);
if ( result > 0 ) {
sqlSession.commit();
}
sqlSession.close();
return result;
}
}
|
package com.tencent.tencentmap.mapsdk.a;
import android.content.Context;
import android.graphics.Bitmap;
public final class on {
private no a = null;
on(no noVar) {
this.a = noVar;
}
public final no a() {
return this.a;
}
public final Bitmap a(Context context) {
return this.a == null ? null : this.a.a(context);
}
}
|
package com.tencent.mm.plugin.nearlife.ui;
import android.graphics.Bitmap;
import android.os.Message;
import com.tencent.mm.a.e;
import com.tencent.mm.a.g;
import com.tencent.mm.sdk.platformtools.ag;
import com.tencent.mm.sdk.platformtools.c;
import com.tencent.mm.sdk.platformtools.x;
class LogoImageView$1 extends ag {
final /* synthetic */ LogoImageView lDZ;
LogoImageView$1(LogoImageView logoImageView) {
this.lDZ = logoImageView;
}
public final void handleMessage(Message message) {
byte[] bArr = (byte[]) message.obj;
if (bArr == null || bArr.length == 0) {
x.e("MicroMsg.LogoImageView", "handleMsg fail, data is null");
return;
}
Bitmap bitmap;
Bitmap bs = c.bs(bArr);
x.d("MicroMsg.LogoImageView", "filePath %s", new Object[]{LogoImageView.a(this.lDZ) + g.u(LogoImageView.b(this.lDZ).getBytes())});
e.b(r2, bArr, bArr.length);
if (bs == null || LogoImageView.c(this.lDZ) <= 0 || LogoImageView.d(this.lDZ) <= 0) {
bitmap = bs;
} else {
bitmap = c.a(bs, LogoImageView.d(this.lDZ), LogoImageView.c(this.lDZ), true, false);
}
this.lDZ.setImageBitmap(bitmap);
}
}
|
/**
*
*/
package site.com.google.anywaywrite.action;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.AbstractAction;
import site.com.google.anywaywrite.component.gui.BgAreaLabel;
import site.com.google.anywaywrite.item.card.BgCardItem;
/**
* ゲーム上から完全に「エリア上の全てのカード」を削除するActionです。 Detail機能から呼ばれることを想定して作っているActionで、
* 通常このActionを呼ぶ必要はないはずです。
*
* @author kitajima
*
*/
public class BgAreaRemoveAction extends AbstractAction implements BgAreaAction {
private static final long serialVersionUID = 1L;
private BgAreaLabel fromArea;
private BgRemoveActionSuccessHook removeActionSuccessHook;
private BgAreaActionEnableControlPlugin enableControlPlugin;
@Override
public final BgAreaLabel getFromArea() {
return fromArea;
}
@Override
public final BgAreaLabel getToArea() {
return null;
}
private final void setFromArea(BgAreaLabel fromArea) {
this.fromArea = fromArea;
}
private final BgRemoveActionSuccessHook getRemoveActionSuccessHook() {
return removeActionSuccessHook;
}
public final void setRemoveActionSuccessHook(BgRemoveActionSuccessHook hook) {
this.removeActionSuccessHook = hook;
}
public final BgAreaActionEnableControlPlugin getEnableControlPlugin() {
return enableControlPlugin;
}
public final void setEnableControlPlugin(
BgAreaActionEnableControlPlugin areaActionEnableControlPlugin) {
this.enableControlPlugin = areaActionEnableControlPlugin;
}
private BgAreaRemoveAction(BgAreaLabel from, String areaName) {
setFromArea(from);
this.putValue(NAME, areaName);
}
public static BgAreaRemoveAction newInstance(BgAreaLabel from) {
return new BgAreaRemoveAction(from, from.getAreaName());
}
public static BgAreaRemoveAction namedInstance(BgAreaLabel from,
String areaName) {
return new BgAreaRemoveAction(from, areaName);
}
@Override
public void actionPerformed(ActionEvent actionevent) {
List<Integer> indexList = new ArrayList<Integer>();
List<BgCardItem> backupList = new ArrayList<BgCardItem>();
List<BgCardItem> cards = getFromArea().getCards();
for (int idx = 0, size = cards.size(); idx < size; idx++) {
BgCardItem backup = BgCardItem.newInstance(getFromArea().getCards()
.get(idx).getInfo());
backup.setDirection(getFromArea().getCards().get(idx)
.getDirection());
backup.setSide(getFromArea().getCards().get(idx).getSide());
backupList.add(backup);
indexList.add(idx);
}
BgCardsRemoveAction action = BgCardsRemoveAction.newInstance(
getFromArea(), indexList);
action.setRemoveActionSuccessHook(getRemoveActionSuccessHook());
action.actionPerformed(new ActionEvent(this,
ActionEvent.ACTION_PERFORMED, getFromArea().getAreaName()));
// BgAreaControlUtil.removeAll(getFromArea());
//
// if (getRemoveActionSuccessHook() == null) {
// return;
// }
// getRemoveActionSuccessHook().actionDone(getFromArea(), backupList,
// indexList);
}
@Override
public boolean isEnabled() {
if (getEnableControlPlugin() != null
&& !getEnableControlPlugin().isEnable()) {
return false;
}
if (getFromArea().getCards().size() == 0) {
return false;
}
return true;
}
}
|
/*
* Ada Sonar Plugin
* Copyright (C) 2010 Akram Ben Aissi
* dev@sonar.codehaus.org
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
*/
package org.sonar.plugins.ada.core;
import java.io.File;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.resources.DefaultProjectFileSystem;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Project;
import org.sonar.api.resources.Resource;
import org.sonar.api.utils.WildcardPattern;
import org.sonar.plugins.ada.Ada;
/**
* This class defines a AdaFile. Its "fromIoFile" infer the package name and class name depending on the complete IO File name.
*/
public class AdaFile extends Resource<AdaDirectory> {
private static final String PACKAGE_SEPARATOR = File.separator;
private static final String PATH_SEPARATOR = "/";
private static final Logger LOG = LoggerFactory.getLogger(AdaFile.class);
private boolean unitTest;
private String filename;
private String packageKey;
private String longName;
private AdaDirectory parent;
/**
* From absolute path.
*
* @param path
* the path
* @param sourceDirs
* the source dirs
* @param unitTest
* the unit test
* @return the php file
*/
public static AdaFile fromAbsolutePath(String path, List<File> sourceDirs, boolean unitTest) {
return path == null ? null : fromIOFile(new File(path), sourceDirs, unitTest);
}
/**
* From absolute path.
*
* @param path
* the path
* @param project
* the current project
* @return the php file
*/
public static AdaFile fromAbsolutePath(String path, Project project) {
AdaFile adaFile = path == null ? null : fromIOFile(new File(path), project.getFileSystem().getSourceDirs(), false);
if (adaFile == null) {
adaFile = path == null ? null : fromIOFile(new File(path), project.getFileSystem().getTestDirs(), true);
}
return adaFile;
}
/**
* Returns a AdaFile if the given file is a php file and can be found in the given directories. This instance will be initialized with
* inferred attribute values
*
* @param file
* the file to load
* @param isUnitTest
* if <code>true</code> the given resource will be marked as a unit test, otherwise it will be marked has a class
* @param dirs
* the dirs
* @return the php file
*/
public static AdaFile fromIOFile(File file, List<File> dirs, boolean isUnitTest) {
// If the file has a valid suffix
if (file == null || !Ada.INSTANCE.hasValidSuffixes(file.getName())) {
return null;
}
String relativePath = DefaultProjectFileSystem.getRelativePath(file, dirs);
// and can be found in the given directories
if (relativePath != null) {
String packageName = null;
String className = relativePath;
if (relativePath.indexOf('/') >= 0) {
packageName = StringUtils.substringBeforeLast(relativePath, PATH_SEPARATOR);
packageName = StringUtils.replace(packageName, PATH_SEPARATOR, PACKAGE_SEPARATOR);
className = StringUtils.substringAfterLast(relativePath, PATH_SEPARATOR);
}
String extension = PACKAGE_SEPARATOR + StringUtils.substringAfterLast(className, PACKAGE_SEPARATOR);
// className = StringUtils.substringBeforeLast(className, PACKAGE_SEPARATOR);
return new AdaFile(packageName, className, extension, isUnitTest);
}
return null;
}
/**
* The default constructor. aPackageName
*
* @param className
* String representing the class name
* @param isUnitTest
* String representing the unit test
* @param aPackageName
* the a package name
*/
public AdaFile(String packageKey, String className, String extension, boolean isUnitTest) {
LOG.debug("aPackageName=[" + packageKey + "], className=[" + className + "], unitTest=[" + isUnitTest + "]");
if (className == null) {
throw new IllegalArgumentException("Php filename can not be null");
}
if (className.indexOf('$') > 0) {
throw new IllegalArgumentException("Php inner classes are not supported yet : " + className);
}
this.filename = StringUtils.trim(className);
String key;
if (StringUtils.isBlank(packageKey)) {
this.packageKey = AdaDirectory.DEFAULT_PACKAGE_NAME;
this.longName = this.filename;
key = new StringBuilder().append(this.filename).append(extension).toString();
} else {
this.packageKey = packageKey.trim();
this.longName = new StringBuilder().append(this.packageKey).append(PACKAGE_SEPARATOR).append(this.filename).toString();
key = new StringBuilder().append(this.packageKey).append(PACKAGE_SEPARATOR).append(this.filename).append(extension).toString();
}
setKey(key);
this.unitTest = isUnitTest;
}
/**
* @return SCOPE_ENTITY
*/
@Override
public String getScope() {
return Resource.SCOPE_ENTITY;
}
/**
* @return QUALIFIER_UNIT_TEST_CLASS or QUALIFIER_CLASS depending whether it is a unit test class
*/
@Override
public String getQualifier() {
return unitTest ? Resource.QUALIFIER_UNIT_TEST_CLASS : Resource.QUALIFIER_FILE;
}
/**
* @return null
*/
@Override
public String getDescription() {
return null;
}
/**
* @return the language.
*/
@Override
public Language getLanguage() {
return Ada.INSTANCE;
}
/**
* {@inheritDoc}
*/
@Override
public String getName() {
return filename;
}
/**
* Returns a concatenation of the package name and the class name.
*
* @returnString representing the complete class name.
* @see org.sonar.api.resources.Resource#getLongName()
*/
@Override
public String getLongName() {
return longName;
}
/**
* Gets the parent.
*
* @return the parent
* @see org.sonar.api.resources.Resource#getParent()
*/
@Override
public AdaDirectory getParent() {
if (parent == null) {
parent = new AdaDirectory(packageKey);
}
return parent;
}
/**
* Match file pattern.
*
* @param antPattern
* the ant pattern
* @return true, if match file pattern
* @see org.sonar.api.resources.Resource#matchFilePattern(java.lang.String)
*/
@Override
public boolean matchFilePattern(String antPattern) {
String patternWithoutFileSuffix = StringUtils.substringBeforeLast(antPattern, PACKAGE_SEPARATOR);
WildcardPattern matcher = WildcardPattern.create(patternWithoutFileSuffix, PACKAGE_SEPARATOR);
return matcher.match(getKey());
}
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE);
builder.append("filename", filename);
builder.append("longName", longName);
builder.append("packageKey", packageKey);
builder.append("parent", parent);
builder.append("unitTest", unitTest);
return builder.toString();
}
}
|
package com.hanbit.spring.core.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.hanbit.spring.core.vo.ArticleVO;
@Repository
public class BoardDAO {
@Autowired
private SqlSession sqlSession;
public List<ArticleVO> selectList() {
return sqlSession.selectList("board.selectList");
}
public List<ArticleVO> searchList(String keyword) {
return sqlSession.selectList("board.searchList", keyword);
}
public int insertArticle(ArticleVO articleVO) {
return sqlSession.insert("board.insertArticle", articleVO);
}
}
|
package models.security;
import com.avaje.ebean.Model;
import models.user.BasicUser;
import javax.persistence.*;
@Entity
public class Token extends Model {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Long id;
public AccessType accessType;
public String uniqueID;
@ManyToOne
public BasicUser user;
} |
package com.easywallet.transactions;
import java.sql.Date;
public class AddMoneyTransactions {
private String tid;
private String email;
private Date date;
private Integer amount;
private String status;
private String source;
private String strt_id;
public AddMoneyTransactions(){
}
public AddMoneyTransactions(String tid, String email, Date date,
Integer amount, String status, String source, String strt_id) {
super();
this.tid = tid;
this.email = email;
this.date = date;
this.amount = amount;
this.status = status;
this.source = source;
this.strt_id = strt_id;
}
public String getTid() {
return tid;
}
public void setTid(String tid) {
this.tid = tid;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public Integer getAmount() {
return amount;
}
public void setAmount(Integer amount) {
this.amount = amount;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public String getStrt_id() {
return strt_id;
}
public void setStrt_id(String strt_id) {
this.strt_id = strt_id;
}
}
|
package com.example.mrcio.applisbonph;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Color;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import database.DBHelper;
public class LoginActivity extends Activity {
DBHelper mydb;
Button enterButton;
Button registerButton;
EditText username;
EditText password;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
final Context context = this;
mydb = new DBHelper(this);
enterButton = (Button)findViewById(R.id.enter);
registerButton = (Button)findViewById(R.id.register);
username = (EditText)findViewById(R.id.etUsername);
password = (EditText)findViewById(R.id.etPassword);
enterButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if("".equals(username.getText().toString()) || "".equals(password.getText().toString())){
Toast.makeText(getApplicationContext(), "Utilizador e Password têm de ser preenchidos",Toast.LENGTH_SHORT).show();
return;
}
Cursor userLogin = mydb.getUserByName(username.getText().toString());
userLogin.moveToFirst();
if(userLogin.getCount() == 0){
Toast.makeText(getApplicationContext(), "Utilizador desconhecido",Toast.LENGTH_SHORT).show();
userLogin.close();
return;
}
String userPassword = userLogin.getString(userLogin.getColumnIndex(DBHelper.USERS_COLUMN_PASSWORD));
int userId = userLogin.getInt(userLogin.getColumnIndex(DBHelper.USERS_COLUMN_ID));
if(password.getText().toString().equals(userPassword)){
finish();
userLogin.close();
Bundle dataBundle = new Bundle();
dataBundle.putInt("userId", userId);
Intent mainPage = new Intent(context, MainActivity.class);
mainPage.putExtras(dataBundle);
startActivity(mainPage);
} else {
Toast.makeText(getApplicationContext(), "Password Errada",Toast.LENGTH_SHORT).show();
userLogin.close();
return;
}
}
});
registerButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent registerPage = new Intent(context, RegisterActivity.class);
startActivity(registerPage);
}
});
}
}
|
/* ChipNode.java */
package list;
import player.Board;
/**
* A ChipNode is a node in a Chip (doubly-linked list). It represents a chip on the board.
*/
public class ChipNode {
/**
* xpos and ypos references the coordinates of the current chip.
* color references the color of the current chip.
* prev references the previous node in the Chip.
* next references the next node in the Chip.
*
*/
public int xpos;
public int ypos;
public int color;
public int id;
protected ChipNode prev;
protected ChipNode next;
/**
* ChipNode() constructor.
* @param x and @param y are the coordinates of the chip.
* @param color is the color of the chip.
* @param p the node previous to this node.
* @param n the node following this node.
*/
ChipNode(int x, int y, int color, ChipNode p, ChipNode n) {
this.color = color;
xpos = x;
ypos = y;
id = x * Board.DIMENSION + y;
prev = p;
next = n;
}
/*
* updateCoordinates() changes the coordinates of this node to the new
* coordinates specified.
* @param x and @param y are the new coordinates.
*/
public void updateCoordinates(int x, int y) {
xpos = x;
ypos = y;
}
}
|
package genscript.parse;
import global.Debug;
import global.StringOps;
import scriptinterface.Index;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Vector;
public class SearchGraph {
protected Node root;
protected String name;
protected int keyCount;
protected boolean doOverwrite;
protected int curMark;
private boolean insertCaseSensitive;
//--- SEARCH GRAPH ---
// ----------------------------------------------------------------------------------------------------------
public SearchGraph() {
keyCount = 0;
root = new Node();
curMark = 0;
insertCaseSensitive = false;
name = "Search Graph";
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public boolean isInsertCaseSensitive() {
return this.insertCaseSensitive;
}
public void setInsertCaseSensitive(boolean caseSensitive) {
this.insertCaseSensitive = caseSensitive;
}
public boolean isDoOverwrite() {
return doOverwrite;
}
public void setDoOverwrite(boolean doOverwrite) {
this.doOverwrite = doOverwrite;
}
public Node getRoot() {
return this.root;
}
public Node findNode(BufferedReader key, boolean nextValue) {
try {
Node curElem = root;
Integer curChar;
curChar = key.read();
if (curChar == null) return null;
while (curChar >= 0) {
if (curElem.hasChild(curChar)) curElem = curElem.getChild(curChar);
else {
if (nextValue) return curElem;
else return null;
}
if (nextValue && curElem.hasValue()) return curElem;
curChar = key.read();
if (curChar == null) return null;
}
if (curElem.hasValue()) return curElem;
else return null;
} catch (IOException ex) {
ex.printStackTrace();
return null;
}
}
public Node findNode(String key, boolean nextValue) {
return findNode(StringOps.stringToBuffer(key), nextValue);
}
/*
* @param nextValue stops searching as soon as a value is found, otherwise the whole key will be searched
* @returns Instance of Object, if key is contained
* null, if key is not contained
* previously set "endOfBuffer" if end of buffer was reached
*/
public Object getValue(BufferedReader key, boolean nextValue) {
Node node = findNode(key, nextValue);
if (node == null || !node.hasValue()) return null;
return node.getValue();
}
public Object getValue(String key, boolean nextValue) {
return getValue(StringOps.stringToBuffer(key), nextValue);
}
public boolean hasKey(BufferedReader key) {
return findNode(key, false) != null;
}
public boolean hasKey(String key) {
return findNode(key, false) != null;
}
/*
* Does only insert, if key does not exist or doOverwrite is true.
*
* @returns The given or the existing key, null if the given key is invalid
*/
public Object insertWord(BufferedReader key, int keyLength, Object value) {
Node res = root.insert(key, value);
if (doOverwrite) res.overwriteValue(value);
else res.setValue(value);
return res.getValue();
}
public Object insertWord(String key, Object value) {
return insertWord(StringOps.stringToBuffer(key), key.length(), value);
}
public Node insert(int key, Object value) {
return root.insert(key, value);
}
public Node insert(int key) {
return root.insert(key);
}
public Node insert(Index key, Object value) {
return root.insert(key, value);
}
public Node insert(Index key) {
return root.insert(key);
}
public boolean traverseTree(SearchGraphIterationCallback callback) {
return root.traverseTree(callback);
}
public Object[] valuesToArray() {
ValuesToArrayCallback valueToArrayCallback = new ValuesToArrayCallback();
traverseTree(valueToArrayCallback);
return valueToArrayCallback.getResult();
}
public String valuesToString() {
ValuesToStringCallback valueToStringCallback = new ValuesToStringCallback();
traverseTree(valueToStringCallback);
return valueToStringCallback.getResult();
}
//------TRAVERSAL------
@Override
public String toString() {
return nodeToString(root);
}
public String nodeToString(Node node) {
curMark++;
node.setMark(curMark);
return node.toString();
}
public int size() {
return this.keyCount;
}
public void deb(String debName, Object msg) {
if (Debug.debugOn && (debName == null || (name != null && name.toUpperCase().equals(debName.toUpperCase()))))
System.out.println(name + ": " + msg);
}
public void deb() {
System.out.println(name);
}
public void deb(Object msg) {
deb(null, msg);
}
public interface SearchGraphIterationCallback {
public boolean handleElem(SearchGraph.Node elem);
}
public class Node {
private Vector<Node> children;
private NonTerminal nonTerminal;
private Object value;
private ParseAction<?> parseEvent;
private int mark;
private int priority;
private boolean inserted;
private boolean rightAssociative;
private int childCount;
private Vector<Node> unacceptedChildren;
public Node(Object value, int initialChildrenCapacity) {
children = new Vector<>(initialChildrenCapacity);
children.setSize(initialChildrenCapacity);
this.value = value;
setPriority(Priority.INTMAXPRIORITY);
mark = 0;
inserted = false;
rightAssociative = false;
childCount = 0;
unacceptedChildren = null;
}
public Node(Object value) {
this(value, 125);
}
public Node() {
this(null);
}
public Node insert(int childIndex, Node child) {
if (child == null) return null;
while (childIndex >= children.size()) children.setSize(children.size() + 32);
Node preChild = children.get(childIndex);
if (preChild != null) {
preChild.setValue(child.getValue());
return preChild;
}
childCount++;
children.set(childIndex, child);
if (insertCaseSensitive) {
if (childIndex >= 65 && childIndex <= 90 && !hasChild(childIndex + 32)) {
childCount++;
children.set(childIndex + 32, child);
}
if (childIndex >= 97 && childIndex <= 122 && !hasChild(childIndex - 32)) {
childCount++;
children.set(childIndex - 32, child);
}
}
return child;
}
public void setUnacceptedChildren(Vector<Node> children) {
this.unacceptedChildren = children;
}
public boolean isUnacceptedChild(int index) {
if (unacceptedChildren == null || index < 0 || index >= unacceptedChildren.size()) return false;
else return this.unacceptedChildren.get(index) != null;
}
public boolean hasUnacceptedChildren() {
return this.unacceptedChildren != null;
}
public int getChildCount() {
return this.childCount;
}
public Node insert(int childIndex, Object childValue) {
return insert(childIndex, new Node(childValue));
}
public Node insert(int childIndex) {
return insert(childIndex, new Node());
}
public Node insert(Index childIndex, Node child) {
return insert(childIndex.getIndex(), child);
}
public Node insert(Index childIndex, Object childValue) {
return insert(childIndex, new Node(childValue));
}
public Node insert(Index childIndex) {
return insert(childIndex, new Node());
}
public Node insert(BufferedReader key, Object value) {
try {
Node curElem = this;
Integer curChar;
curChar = key.read();
if (curChar == null) return null;
while (curChar > 0) {
curElem = curElem.insert(curChar);
curChar = key.read();
if (curChar == null) return null;
}
curElem.setValue(value);
return curElem;
} catch (IOException ex) {
ex.printStackTrace();
return null;
}
}
public Node insert(String key, Object value) {
return insert(StringOps.stringToBuffer(key), value);
}
public Node insertArray(byte[] indices, Node node) {
for (int index : indices) {
Node current = insert(index, node);
if (current != node) throw new RuntimeException("Invalid array node.");
}
return node;
}
public Node insertArray(byte[] indices, Object value) {
return insertArray(indices, new Node(value));
}
public Node insertArray(byte[] indices) {
return insertArray(indices, this);
}
public boolean removeChild(int childIndex) {
if (hasChild(childIndex)) {
children.remove(childIndex);
return true;
} else return false;
}
public void copyFromNode(Node sourceNode, boolean onlyChildren) {
int index = 0;
for (Node child : sourceNode.getChildren()) {
if (child != null && !this.hasChild(index)) insert(index, child);
index++;
}
if (!onlyChildren) setValue(sourceNode.getValue());
}
public void copyToNode(Node targetNode, boolean onlyChildren) {
int index = 0;
for (Node child : getChildren()) {
if (child != null && !targetNode.hasChild(index)) targetNode.insert(index, child);
index++;
}
if (!onlyChildren) targetNode.setValue(this.getValue());
}
public int childCount() {
return this.children.size();
}
public Node getChild(int index) {
if (index < 0 || index >= children.size()) return null;
else return children.get(index);
}
public Node getChild(Index index) {
if (index != null) return getChild(index.getIndex());
else return null;
}
public Vector<Node> getChildren() {
return this.children;
}
public boolean hasChild(int index) {
return getChild(index) != null;
}
public Object getValue() {
return value;
}
public Node setValue(Object value) {
if (value == null) return this;
if (!doOverwrite && this.value != null && this.value != value)
throw new RuntimeException("Node already has a value: " + this.value + ", new value: " + value);
this.value = value;
return this;
}
public Node overwriteValue(Object value) {
this.value = value;
return this;
}
public boolean isRightAssociative() {
return this.rightAssociative;
}
public Node setRightAssociative() {
this.rightAssociative = true;
return this;
}
public boolean isInserted() {
return inserted;
}
public void setInserted() {
this.inserted = true;
}
public Node clearValue() {
this.value = null;
return this;
}
public SearchGraph getSearchGraph() {
return SearchGraph.this;
}
public boolean hasValue() {
return value != null;
}
public boolean traverseTree(SearchGraphIterationCallback callback) {
if (this.hasValue()) if (!callback.handleElem(this)) return false;
for (Node child : children) {
if (child != null) if (!child.traverseTree(callback)) return false;
}
return true;
}
public String toString() {
String result = "";
for (int i = 0; i < children.size(); i++) {
Node child = children.get(i);
if (child != null && child.getMark() < mark) {
child.setMark(mark);
if (!result.equals("")) result += ", ";
result += i + "-(" + child.toString() + ")";
}
}
if (nonTerminal != null && nonTerminal.getNextNode() != null) {
nonTerminal.getNextNode().setMark(mark);
result += "NT-(" + nonTerminal.getNextNode().toString() + ")";
}
if (value != null) result = '[' + this.value.toString() + ']' + result;
return result;
}
public int getMark() {
return mark;
}
public void setMark(int mark) {
this.mark = mark;
}
public NonTerminal getNonTerminal() {
return nonTerminal;
}
public Node setNonTerminal(NTProductions subSearchGraph) {
return setNonTerminal(subSearchGraph, Priority.INTMINPRIORITY);
}
public Node setNonTerminal(NTProductions subSearchGraph, Node node, int priority) {
if (hasNonTerminal()) {
if (getNonTerminal().getSubSearchGraph() != subSearchGraph)
throw new RuntimeException("No NonTerminal overwrite allowed.");
else return getNonTerminal().getNextNode();
}
NonTerminal nonTerminal = new NonTerminal(node, subSearchGraph, priority);
this.nonTerminal = nonTerminal;
return node;
}
public Node setNonTerminal(NTProductions subSearchGraph, int priority) {
return setNonTerminal(subSearchGraph, new Node(), priority);
}
public Node setNonTerminal(NTProductions subSearchGraph, Node node) {
return setNonTerminal(subSearchGraph, node, Priority.INTMINPRIORITY);
}
public boolean hasNonTerminal() {
return (this.nonTerminal != null);
}
public int getPriority() {
return priority;
}
public Node setPriority(int priority) {
this.priority = priority;
return this;
}
public boolean isMinPriority() {
return priority <= Priority.INTMINPRIORITY;
}
public boolean isMaxPriority() {
return priority >= Priority.INTMAXPRIORITY;
}
public boolean checkPriority(int priority) {
if (rightAssociative) return getPriority() < priority;
else return getPriority() <= priority;
}
public boolean hasParseEvent() {
return this.parseEvent != null;
}
public ParseAction<?> getParseEvent() {
return this.parseEvent;
}
public Node setAction(ParseAction<?> parseEvent, Object value) {
this.parseEvent = parseEvent;
return setValue(value);
}
public Node setAction(ParseAction<?> parseEvent) {
this.parseEvent = parseEvent;
return this;
}
}
public class NonTerminal {
private Node nextNode;
private NTProductions subSearchGraph;
private int innerPriority;
public NonTerminal(Node nextNode, NTProductions subSearchGraph, int innerPriority) {
this.nextNode = nextNode;
this.subSearchGraph = subSearchGraph;
this.innerPriority = innerPriority;
}
public NonTerminal(Node nextNode, NTProductions subSearchGraph) {
this(nextNode, subSearchGraph, Integer.MIN_VALUE);
}
public Node getNextNode() {
return nextNode;
}
public NTProductions getSubSearchGraph() {
return subSearchGraph;
}
public int getPriority() {
return innerPriority;
}
public void setPriority(int innerPriority) {
this.innerPriority = innerPriority;
}
}
private class ValuesToArrayCallback implements SearchGraphIterationCallback {
private Object[] result;
private int arrayPos = 0;
public ValuesToArrayCallback() {
result = new Object[keyCount];
}
@Override
public boolean handleElem(Node elem) {
result[arrayPos++] = elem;
return true;
}
public Object[] getResult() {
return result;
}
}
private class ValuesToStringCallback implements SearchGraphIterationCallback {
private String result;
public ValuesToStringCallback() {
result = "";
}
@Override
public boolean handleElem(Node elem) {
if (!result.equals("")) result += ", ";
result += elem.getValue().toString();
return true;
}
public String getResult() {
return result;
}
}
}
|
package TableSorter_sortableTests;
import cs5387.TableSorter;
import cs5387.Table;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import cs5387.Table;
import cs5387.TableSorter;
class Size3x3Mixed4_5TableTest {
@Test
void test() {
int [] vals = new int[] { 3, 8, -4, //4 positives and 5 negatives
-6, -5, 1,
-9, 2, -10
};
int N = vals.length; //get the amount of values, must be a square number
Table t0 = null;
try {
t0 = new Table (N,vals);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} // create a dummy table
TableSorter.sortable(t0); //call the sortable method
assertTrue(TableSorter.isSorted(t0));
}
}
|
package com.qswy.app.adapter;
import android.content.Context;
import com.qswy.app.model.TempAngel;
import java.util.ArrayList;
/**
* Created by ryl on 2016/11/24.
*/
public class HistoryPayListAdapter extends MyBaseAdapter<TempAngel> {
public HistoryPayListAdapter(Context context, int itemLayoutResId, ArrayList<TempAngel> list) {
super(context, itemLayoutResId, list);
}
@Override
public void convert(ViewHolder viewHolder, TempAngel item, int position) {
}
}
|
package ch.ubx.startlist.server;
import java.util.Set;
import ch.ubx.startlist.shared.Airfield;
public interface AirfieldDAO {
public void addAirfield(Airfield airfield);
public void addAirfields(Set<Airfield> airfields);
public Set<Airfield> getAirfields();
}
|
package com.espendwise.manta.web.controllers;
import com.espendwise.manta.model.data.BusEntityAssocData;
import com.espendwise.manta.model.data.PropertyData;
import com.espendwise.manta.model.view.UserListView;
import com.espendwise.manta.service.DatabaseUpdateException;
import com.espendwise.manta.service.PropertyService;
import com.espendwise.manta.service.SiteService;
import com.espendwise.manta.service.UserService;
import com.espendwise.manta.spi.AutoClean;
import com.espendwise.manta.spi.SuccessMessage;
import com.espendwise.manta.util.*;
import com.espendwise.manta.util.alert.ArgumentedMessage;
import com.espendwise.manta.util.criteria.UserListViewCriteria;
import com.espendwise.manta.util.validation.ValidationException;
import com.espendwise.manta.web.forms.SiteUserFilterForm;
import com.espendwise.manta.web.forms.SiteUserFilterResultForm;
import com.espendwise.manta.web.resolver.DatabaseWebUpdateExceptionResolver;
import com.espendwise.manta.web.util.*;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.stereotype.Controller;
import org.springframework.validation.DataBinder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.WebRequest;
import javax.servlet.http.HttpSession;
import java.util.List;
@Controller
@RequestMapping(UrlPathKey.SITE.USERS)
@SessionAttributes({SessionKey.SITE_USER_FILTER, SessionKey.SITE_USER_FILTER_RESULT})
@AutoClean(SessionKey.SITE_USER_FILTER)
public class SiteUserController extends BaseController {
private static final Logger logger = Logger.getLogger(SiteUserController.class);
private UserService userService;
private SiteService siteService;
private PropertyService propertyService;
@Autowired
public SiteUserController(UserService userService,
SiteService siteService,
PropertyService propertyService) {
this.userService = userService;
this.siteService = siteService;
this.propertyService = propertyService;
}
@Override
public void initBinder(DataBinder binder) {
binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
}
public String handleValidationException(ValidationException ex, WebRequest request) {
WebErrors webErrors = new WebErrors(request);
/* webErrors.putErrors(ex, new SiteWebUpdateExceptionResolver());*/
return "site/users";
}
public String handleDatabaseUpdateException(DatabaseUpdateException ex, WebRequest request) {
WebErrors webErrors = new WebErrors(request);
webErrors.putErrors(ex, new DatabaseWebUpdateExceptionResolver());
return "site/users";
}
@RequestMapping(value = {"/", ""}, method = RequestMethod.GET)
public String view(@ModelAttribute(SessionKey.SITE_USER_FILTER) SiteUserFilterForm filterForm) {
return "site/users";
}
@RequestMapping(value = "/filter", method = RequestMethod.GET)
public String findUsers(WebRequest request,
@ModelAttribute(SessionKey.SITE_USER_FILTER) SiteUserFilterForm filterForm,
@ModelAttribute(SessionKey.SITE_USER_FILTER_RESULT) SiteUserFilterResultForm resultForm) throws Exception {
WebErrors webErrors = new WebErrors(request);
List<? extends ArgumentedMessage> validationErrors = WebAction.validate(filterForm);
if (!validationErrors.isEmpty()) {
webErrors.putErrors(validationErrors);
return "site/users";
}
doSearch(filterForm, resultForm);
return "site/users";
}
@SuccessMessage
@RequestMapping(value = "/update", method = RequestMethod.POST)
public String update(@PathVariable(IdPathKey.LOCATION_ID) Long locationId,
@ModelAttribute(SessionKey.SITE_USER_FILTER) SiteUserFilterForm filterForm,
@ModelAttribute(SessionKey.SITE_USER_FILTER_RESULT) SiteUserFilterResultForm resultForm) throws Exception {
logger.info("site/users/update()=> BEGIN");
Long storeId = getStoreId();
logger.info("site/users/update()=> siteId: " + locationId);
logger.info("site/users/update()=> storeId: " + storeId);
List<UserListView> selected = resultForm.getUsers().getSelected();
List<UserListView> deselected = resultForm.getUsers().getNewlyDeselected();
siteService.configureSiteUsersList(locationId,
storeId,
selected,
deselected);
propertyService.configureEntityProperty(locationId, RefCodeNames.PROPERTY_TYPE_CD.SITE_PRIMARY_USER, resultForm.getPrimaryUser());
doSearch(filterForm, resultForm);
logger.info("site/users/update()=> END.");
return "site/users";
}
@RequestMapping(value = "/filter/sortby/{field}", method = RequestMethod.GET)
public String sort(@ModelAttribute(SessionKey.SITE_USER_FILTER_RESULT) SiteUserFilterResultForm form, @PathVariable String field) throws Exception {
WebSort.sort(form, field);
return "site/users";
}
@ModelAttribute(SessionKey.SITE_USER_FILTER_RESULT)
public SiteUserFilterResultForm initFilterResult(HttpSession session) {
logger.info("initFilterResult()=> init....");
SiteUserFilterResultForm form = (SiteUserFilterResultForm) session.getAttribute(SessionKey.SITE_USER_FILTER_RESULT);
logger.info("initFilterResult()=> form: " + form);
if (form == null) {
form = new SiteUserFilterResultForm();
}
if (Utility.isSet(form.getResult())) {
form.reset();
}
logger.info("initFilterResult()=> init.OK!");
return form;
}
@ModelAttribute(SessionKey.SITE_USER_FILTER_RESULT)
public SiteUserFilterResultForm init(HttpSession session) {
logger.info("initFilterResult()=> init....");
SiteUserFilterResultForm form = (SiteUserFilterResultForm) session.getAttribute(SessionKey.SITE_USER_FILTER_RESULT);
logger.info("initFilterResult()=> form: " + form);
if (form == null) {
form = new SiteUserFilterResultForm();
}
if (Utility.isSet(form.getResult())) {
form.reset();
}
logger.info("initFilterResult()=> init.OK!");
return form;
}
@ModelAttribute(SessionKey.SITE_USER_FILTER)
public SiteUserFilterForm initFilter(HttpSession session, @PathVariable(IdPathKey.LOCATION_ID) Long locationId) {
logger.info("initFilter()=> init....");
SiteUserFilterForm form = (SiteUserFilterForm) session.getAttribute(SessionKey.SITE_USER_FILTER);
if (form == null || !form.isInitialized()) {
form = new SiteUserFilterForm(locationId);
form.initialize();
}
logger.info("initFilter()=> form: " + form);
logger.info("initFilter()=> init.OK!");
return form;
}
private void doSearch (SiteUserFilterForm filterForm, SiteUserFilterResultForm resultForm) {
resultForm.reset();
Long siteId = null;
if (Utility.isSet(filterForm.getSiteId())) {
siteId = Long.valueOf(filterForm.getSiteId());
}
UserListViewCriteria criteria = new UserListViewCriteria(getStoreId(), Constants.FILTER_RESULT_LIMIT.USER);
criteria.setUserId(filterForm.getUserId());
criteria.setUserName(filterForm.getUserName());
criteria.setSiteId(siteId);
criteria.setActiveOnly(!filterForm.getShowInactive());
criteria.setUserNameFilterType(filterForm.getUserNameFilterType());
BusEntityAssocData accountAssoc = siteService.findSiteAccountAssoc(siteId);
if (accountAssoc != null) {
criteria.setAccountFilter(Utility.toList(accountAssoc.getBusEntity2Id()));
}
List<UserListView> configured = userService.findUsersByCriteria(criteria);
criteria.setSiteId(null);
List<UserListView> users = filterForm.getShowConfiguredOnly()
? configured : userService.findUsersByCriteria(criteria);
logger.info("findUsers()=> user: " + users.size());
logger.info("findUsers()=> configured: " + configured.size());
SelectableObjects<UserListView> selectableObj = new SelectableObjects<UserListView>(
users,
configured,
AppComparator.USER_LIST_VIEW_COMPARATOR);
resultForm.setUsers(selectableObj);
List<PropertyData> properties = propertyService.findEntityPropertyValues(siteId, RefCodeNames.PROPERTY_TYPE_CD.SITE_PRIMARY_USER);
resultForm.setPrimaryUser(PropertyUtil.toFirstValue(PropertyUtil.findActiveP(properties)));
WebSort.sort(resultForm, UserListView.USER_NAME);
}
}
|
public class ClassB {
public void doSomething(){
System.out.println("ClassB do something...");
}
}
|
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.event.*;
public class MazeGUI extends CenterFrame implements ActionListener
{
private Maze maze;
private JButton btn;
public MazeGUI(int width, int height, Maze maze)
{
super (width, height, "Maze");
setLayout(new BorderLayout());
setSize(width, height);
setResizable(false);
DrawPanel draw = new DrawPanel();
draw.setDrawable(maze);
add(draw, BorderLayout.CENTER);
btn = new JButton("Solve!");
btn.setBackground(java.awt.Color.white);
btn.setActionCommand("Solve");
add(btn, BorderLayout.SOUTH);
btn.addActionListener(this);
//repaint periodically (see action performed)
Timer timer = new Timer(50, this);
timer.setActionCommand("Timer");
timer.start();
this.maze = maze;
setVisible(true);
}
public void actionPerformed(ActionEvent ae)
{
if (ae.getActionCommand().equals("Solve"))
{
btn.setEnabled(false);
Thread t = new Thread(maze);
t.start();
}
else
{
repaint();
}
}
} |
package com.martinsanguin.msscbrewery.services;
import com.martinsanguin.msscbrewery.web.model.CustomerDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.UUID;
@Slf4j
@Service
public class CustomerServiceImpl implements CustomerService {
@Override
public CustomerDto getById(UUID id) {
return CustomerDto.builder().id(UUID.randomUUID())
.name("Martin")
.build();
}
@Override
public CustomerDto saveCustomer(CustomerDto customerDto) {
return CustomerDto.builder().id(UUID.randomUUID())
.name(customerDto.getName())
.build();
}
@Override
public void updateCustomer(UUID id, CustomerDto customerDto) {
log.debug("Update customer..");
}
@Override
public void deleteCustomer(UUID id) {
log.debug("Delete customer..");
}
}
|
package za.ac.cput.Repository;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import za.ac.cput.Entity.Cashier;
import za.ac.cput.Factory.CashierFactory;
import static org.junit.jupiter.api.Assertions.*;
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class CashierRepositoryTest {
private static Cashier cashier = CashierFactory.createsCashier("14258","James","Zack",80.00);
private static CashierRepository cashierRepository = CashierRepository.getRepository();
@Test
@Order(1)
void TestCreate() {
Cashier create = cashierRepository.create(cashier);
assertEquals(create.getCashierID(),cashier.getCashierID());
System.out.println("Create: " +create);
}
@Test
@Order(2)
void TestUpdate() {
Cashier update =new Cashier.Builder().copy(cashier).setName("Adam").build();
System.out.println(cashierRepository.update(update));
assertNotNull(cashierRepository.update(update));
}
@Test
@Order(3)
void testRead() {
Cashier c = cashierRepository.read(cashier.getCashierID());
assertNotNull(c);
System.out.println("Read: " +c);
}
@Test
@Order(4)
void testDelete() {
Boolean success =cashierRepository.delete(cashier.getCashierID());
assertTrue(success);
System.out.println("Delete: " +success);
}
}
|
package com.example.jkl.service.impl;
import com.example.jkl.config.MybatisConfig;
import com.example.jkl.dao.GoodsDao;
import com.example.jkl.pojo.Goods;
import com.example.jkl.service.GoodsService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Slf4j
@Service
public class GoodsServiceImpl implements GoodsService {
@Autowired
GoodsDao goodsDao;
@Autowired
MybatisConfig mybatisConfig;
@Override
public Integer addGoods(Goods goods) {
return goodsDao.addGoods(goods);
}
@Override
public Integer deleteGoods(Integer id) {
return goodsDao.deleteGoods(id);
}
@Override
public Integer updateGoods(Goods goods) {
return goodsDao.updateGoods(goods);
}
@Override
public List<Goods> findGoodsByGName(String gName, Integer pageNumber, Integer pageSize) {
PageHelper.startPage(pageNumber, pageSize);
List<Goods> all = goodsDao.findGoodsByGName(gName);
PageInfo<Goods> pageInfo = new PageInfo<>(all);
log.info("all-{}", all);
log.info("pageInfo.getList()-{}", pageInfo.getList());
log.info("pageNumber-{},pageSize-{}", pageNumber, pageSize);
return pageInfo.getList();
}
@Override
public List<Goods> findAllGoods(Integer pageNumber, Integer pageSize) {
//开始分页必须写在上面
PageHelper.startPage(pageNumber, pageSize);
List<Goods> all = goodsDao.findAllGoods();
PageInfo<Goods> pageInfo = new PageInfo<>(all);
log.info("all-{}", all);
log.info("pageInfo.getList()-{}", pageInfo.getList());
log.info("pageNumber-{},pageSize-{}", pageNumber, pageSize);
return pageInfo.getList();
}
@Override
public Integer addGoodsList(List<Goods> goodsList) {
return goodsDao.addGoodsList(goodsList);
}
@Override
public Integer deleteGoodsList(List<Integer> ids) {
return goodsDao.deleteGoodsList(ids);
}
} |
package com.cg.wishlist.dao;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.cg.entity.Product;
import com.cg.entity.Wishlist;
@Repository
public interface ProductDao extends JpaRepository<Product, Integer> {
}
|
package com.tencent.mm.opensdk.modelbiz;
public class AddCardToWXCardPackage {
private static final String TAG = "MicroMsg.AddCardToWXCardPackage";
}
|
package practisepkg;
public class apple {
int bikespeed=100;
int suzuki=250;
}
|
/**
* Copyright 2014 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 rx.jmh;
import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.logic.BlackHole;
import rx.functions.Func1;
public class Baseline {
@GenerateMicroBenchmark
public void forLoopInvokingFunction(BlackHole bh, Input input) {
for (int value = 0; value < input.size; value++) {
bh.consume(IDENTITY_FUNCTION.call(value));
}
}
private static final Func1<Integer, Integer> IDENTITY_FUNCTION = new Func1<Integer, Integer>() {
@Override
public Integer call(Integer value) {
return value;
}
};
@State(Scope.Thread)
public static class Input {
@Param({ "1024", "1048576" })
public int size;
}
}
|
package com.rc.portal.service.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.rc.commons.util.InfoUtil;
import com.rc.portal.dao.CPaymentWayDAO;
import com.rc.portal.dao.TSysParameterDAO;
import com.rc.portal.service.CPaymentWayManager;
import com.rc.portal.vo.CPaymentWay;
import com.rc.portal.vo.CPaymentWayExample;
import com.rc.portal.vo.TMemberReceiverLatLon;
public class CPaymentWayManagerImpl implements CPaymentWayManager {
private CPaymentWayDAO cpaymentwaydao;
private TSysParameterDAO tsysparameterdao;
public CPaymentWayManagerImpl() {
super();
}
public void setCpaymentwaydao(CPaymentWayDAO cpaymentwaydao){
this.cpaymentwaydao=cpaymentwaydao;
}
public CPaymentWayDAO getCpaymentwaydao(){
return this.cpaymentwaydao;
}
public int countByExample(CPaymentWayExample example) throws SQLException{
return cpaymentwaydao. countByExample( example);
}
public int deleteByExample(CPaymentWayExample example) throws SQLException{
return cpaymentwaydao. deleteByExample( example);
}
public int deleteByPrimaryKey(Long id) throws SQLException{
return cpaymentwaydao. deleteByPrimaryKey( id);
}
public Long insert(CPaymentWay record) throws SQLException{
return cpaymentwaydao. insert( record);
}
public Long insertSelective(CPaymentWay record) throws SQLException{
return cpaymentwaydao. insertSelective( record);
}
public List selectByExample(CPaymentWayExample example) throws SQLException{
return cpaymentwaydao. selectByExample( example);
}
public CPaymentWay selectByPrimaryKey(Long id) throws SQLException{
return cpaymentwaydao. selectByPrimaryKey( id);
}
public int updateByExampleSelective(CPaymentWay record, CPaymentWayExample example) throws SQLException{
return cpaymentwaydao. updateByExampleSelective( record, example);
}
public int updateByExample(CPaymentWay record, CPaymentWayExample example) throws SQLException{
return cpaymentwaydao. updateByExample( record, example);
}
public int updateByPrimaryKeySelective(CPaymentWay record) throws SQLException{
return cpaymentwaydao. updateByPrimaryKeySelective( record);
}
public int updateByPrimaryKey(CPaymentWay record) throws SQLException{
return cpaymentwaydao. updateByPrimaryKey( record);
}
public List<CPaymentWay> selectByExampleAndReceiverId(
CPaymentWayExample example, TMemberReceiverLatLon receiverLatLon) throws SQLException {
List<CPaymentWay> paymentList =cpaymentwaydao. selectByExample( example);
List<CPaymentWay> paymentListnew = new ArrayList<CPaymentWay>();
if(receiverLatLon!=null&&receiverLatLon.getArea()!=null){
String hdfk_area =tsysparameterdao.getKeys("paymethod_hdfk_area");//支付方式支持货到付款地区
if(receiverLatLon.getArea().indexOf(hdfk_area)==-1){//判断北京
for(CPaymentWay payWay:paymentList){
if(!payWay.getPaymentCode().equals(InfoUtil.getInstance().getInfo("config", "payment.hdfk"))){
paymentListnew.add(payWay);
}
}
}else{
paymentListnew.addAll(paymentList);
}
}else{
paymentListnew.addAll(paymentList);
}
return paymentListnew;
}
public TSysParameterDAO getTsysparameterdao() {
return tsysparameterdao;
}
public void setTsysparameterdao(TSysParameterDAO tsysparameterdao) {
this.tsysparameterdao = tsysparameterdao;
}
}
|
package com.philippe.app.domain;
public class AckData extends CommonData {
private boolean status;
}
|
package com.example.roomdemo;
import android.app.Application;
import android.os.AsyncTask;
import androidx.lifecycle.LiveData;
import java.util.List;
public class Repo {
private TextDao TextDao;
private LiveData<List<Word>> mAllWords;
Repo(Application application) {
RoomDatabase db = RoomDatabase.getDatabase(application);
TextDao = db.wordDao();
mAllWords = TextDao.getAlphabetizedWords();
}
public void insert(Word word) {
new insertAsyncTask(TextDao).execute(word);
}
public void deleteAll() {
new deleteAllEntriesAsyncTask(TextDao).execute();
}
public void deleteWord(Word word) {
new deleteEntryAsyncTask(TextDao).execute(word);
}
LiveData<List<Word>> getAllWords() {
return mAllWords;
}
private static class insertAsyncTask extends AsyncTask<Word, Void, Void> {
private TextDao mAsyncTaskDao;
insertAsyncTask(TextDao dao) {
mAsyncTaskDao = dao;
}
@Override
protected Void doInBackground(final Word... params) {
mAsyncTaskDao.insert(params[0]);
return null;
}
}
private static class deleteEntryAsyncTask extends AsyncTask<Word, Void, Void> {
private TextDao mAsyncTaskDao;
deleteEntryAsyncTask(TextDao dao) {
mAsyncTaskDao = dao;
}
@Override
protected Void doInBackground(final Word... params) {
mAsyncTaskDao.deleteEntry(params[0]);
return null;
}
}
private static class deleteAllEntriesAsyncTask extends AsyncTask<Void, Void, Void> {
private TextDao mAsyncTaskDao;
deleteAllEntriesAsyncTask(TextDao dao) {
mAsyncTaskDao = dao;
}
@Override
protected Void doInBackground(Void... voids) {
mAsyncTaskDao.deleteAll();
return null;
}
}
}
|
package company.com;
public class Project {
public static void main(String[] args) {
Main m=new Main();
m.setTitle("Main menu");
m.setVisible(true);
}
}
|
package com.chris.projects.fx.ftp.entity.order;
public abstract class Order {
private String orderId;
private String cloId;
private String symbol;
private String dealtCcy;
private double price;
private double orderAmt;
private long timeStamp;
public Order(String orderId, String cloId, String symbol, String dealtCcy, double price, double orderAmt, long timeStamp) {
this.orderId = orderId;
this.cloId = cloId;
this.symbol = symbol;
this.dealtCcy = dealtCcy;
this.price = price;
this.orderAmt = orderAmt;
this.timeStamp = timeStamp;
}
public String getOrderId() {
return orderId;
}
public String getCloId() {
return cloId;
}
public String getSymbol() {
return symbol;
}
public String getDealtCcy() {
return dealtCcy;
}
public double getPrice() {
return price;
}
public double getOrderAmt() {
return orderAmt;
}
public long getTimeStamp() {
return timeStamp;
}
}
|
package com.android.demo;
import android.app.TabActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Display;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.RadioButton;
import android.widget.TabHost;
import android.widget.Toast;
public class MainActivity extends TabActivity {
private long mExitTime;
private TabHost tabHost;
private ImageView mTabImg;
private int zero = 0;
private int one = 0;
private int currIndex = 0;
private Animation animation;
private RadioButton guide_home, guide_tfaccount, guide_account, guide_cart,
guide_put;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_one);
initTab();
init();
}
private void initTab() {
tabHost = getTabHost();
Intent tabIntent = new Intent(MainActivity.this, MaintwoActivity.class);
Bundle bundle = new Bundle();
bundle.putString("page", "1"); //假设你的list是字符串类型
tabIntent.putExtras(bundle);
tabHost.addTab(tabHost.newTabSpec("guide_home")
.setIndicator("guide_home")
.setContent(tabIntent));
tabHost.addTab(tabHost.newTabSpec("guide_tfaccount")
.setIndicator("guide_tfaccount")
.setContent(new Intent(this, MaintwoActivity.class).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)));
tabHost.addTab(tabHost.newTabSpec("guide_account")
.setIndicator("guide_account")
.setContent(new Intent(this, MaintwoActivity.class).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)));
tabHost.addTab(tabHost.newTabSpec("guide_cart")
.setIndicator("guide_cart")
.setContent(new Intent(this, GoCartActivity.class).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)));
tabHost.addTab(tabHost.newTabSpec("guide_put")
.setIndicator("guide_put")
.setContent(new Intent(this, PutActivity.class).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)));
}
private void init() {
mTabImg = (ImageView) findViewById(R.id.img_tab_now);
Display currDisplay = getWindowManager().getDefaultDisplay();// ��ȡ��Ļ��ǰ�ֱ���
int displayWidth = currDisplay.getWidth();
one = displayWidth / 5;
guide_home = (RadioButton) findViewById(R.id.guide_home);
guide_tfaccount = (RadioButton) findViewById(R.id.guide_tfaccount);
guide_account = (RadioButton) findViewById(R.id.guide_account);
guide_cart = (RadioButton) findViewById(R.id.guide_cart);
guide_put = (RadioButton) findViewById(R.id.guide_put);
guide_home.setOnClickListener(new MyOnPageChangeListener());
guide_tfaccount.setOnClickListener(new MyOnPageChangeListener());
guide_account.setOnClickListener(new MyOnPageChangeListener());
guide_cart.setOnClickListener(new MyOnPageChangeListener());
guide_put.setOnClickListener(new MyOnPageChangeListener());
}
private class MyOnPageChangeListener implements OnClickListener {
@Override
public void onClick(View v) {
animation = null;
switch (v.getId()) {
case R.id.guide_home:
if (currIndex == 1) {
animation = new TranslateAnimation(one, 0, 0, 0);
} else if (currIndex == 2) {
animation = new TranslateAnimation(one * 2, 0, 0, 0);
} else if (currIndex == 3) {
animation = new TranslateAnimation(one * 3, 0, 0, 0);
} else if (currIndex == 4) {
animation = new TranslateAnimation(one * 4, 0, 0, 0);
}
currIndex = 0;
tabHost.setCurrentTabByTag("guide_home");
break;
case R.id.guide_account:
if (currIndex == 0) {
animation = new TranslateAnimation(zero, one, 0, 0);
} else if (currIndex == 2) {
animation = new TranslateAnimation(one * 2, one, 0, 0);
} else if (currIndex == 3) {
animation = new TranslateAnimation(one * 3, one, 0, 0);
} else if (currIndex == 4) {
animation = new TranslateAnimation(one * 4, one, 0, 0);
}
currIndex = 1;
tabHost.setCurrentTabByTag("guide_account");
break;
case R.id.guide_put:
if (currIndex == 0) {
animation = new TranslateAnimation(zero, one * 2, 0, 0);
} else if (currIndex == 1) {
animation = new TranslateAnimation(one, one * 2, 0, 0);
} else if (currIndex == 3) {
animation = new TranslateAnimation(one * 3, one * 2, 0, 0);
} else if (currIndex == 4) {
animation = new TranslateAnimation(one * 4, one * 2, 0, 0);
}
currIndex = 2;
tabHost.setCurrentTabByTag("guide_put");
break;
case R.id.guide_cart:
if (currIndex == 0) {
animation = new TranslateAnimation(zero, one * 3, 0, 0);
} else if (currIndex == 1) {
animation = new TranslateAnimation(one, one * 3, 0, 0);
} else if (currIndex == 2) {
animation = new TranslateAnimation(one * 2, one * 3, 0, 0);
} else if (currIndex == 4) {
animation = new TranslateAnimation(one * 4, one * 3, 0, 0);
}
currIndex = 3;
tabHost.setCurrentTabByTag("guide_cart");
break;
case R.id.guide_tfaccount:
if (currIndex == 0) {
animation = new TranslateAnimation(zero, one * 4, 0, 0);
} else if (currIndex == 1) {
animation = new TranslateAnimation(one, one * 4, 0, 0);
} else if (currIndex == 2) {
animation = new TranslateAnimation(one * 2, one * 4, 0, 0);
} else if (currIndex == 3) {
animation = new TranslateAnimation(one * 3, one * 4, 0, 0);
}
currIndex = 4;
tabHost.setCurrentTabByTag("guide_tfaccount");
break;
}
if (animation != null) {
animation.setFillAfter(true);// True:ͼƬͣ�ڶ�������λ��
animation.setDuration(150);
mTabImg.startAnimation(animation);
}
}
}
public boolean dispatchKeyEvent(KeyEvent event) {
if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
if (event.getAction() == KeyEvent.ACTION_DOWN
&& event.getRepeatCount() == 0) {
if (currIndex != 0) {
new MyOnPageChangeListener().onClick(guide_home);
guide_home.setChecked(true);
} else {
if ((System.currentTimeMillis() - mExitTime) > 2000) {// ������ΰ���ʱ��������2000���룬���˳�
Toast.makeText(this, "退出程序", Toast.LENGTH_SHORT)
.show();
mExitTime = System.currentTimeMillis();// ����mExitTime
} else {
int id = android.os.Process.myPid();
if (id != 0) {
android.os.Process.killProcess(id);
}
}
}
return true;
}
}
return super.dispatchKeyEvent(event);
}
} |
package org.faucon.dataset.cloud.log;
import java.util.List;
public class SensuLog {
private String id = null;
private Changes changes = null;
private String description = null;
private String directory = null;
private Event event = null;
private String file = null;
private String filter = null;
private Handler handler = null;
private String handler_name = null;
private In_progress in_progress = null;
private String level = null;
private String message = null;
private String name = null;
private String note = null;
private List<String> output = null;
private Payload payload = null;
private Server server = null;
private Settings settings = null;
private String signal = null;
private List<String> subscribers = null;
private String task = null;
private String timestamp = null;
private String type = null;
public Changes getChanges() {
return changes;
}
public void setChanges(Changes changes) {
this.changes = changes;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDirectory() {
return directory;
}
public void setDirectory(String directory) {
this.directory = directory;
}
public Event getEvent() {
return event;
}
public void setEvent(Event event) {
this.event = event;
}
public String getFile() {
return file;
}
public void setFile(String file) {
this.file = file;
}
public String getFilter() {
return filter;
}
public void setFilter(String filter) {
this.filter = filter;
}
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
public String getHandler_name() {
return handler_name;
}
public void setHandler_name(String handler_name) {
this.handler_name = handler_name;
}
public In_progress getIn_progress() {
return in_progress;
}
public void setIn_progress(In_progress in_progress) {
this.in_progress = in_progress;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note;
}
public List<String> getOutput() {
return output;
}
public void setOutput(List<String> output) {
this.output = output;
}
public Payload getPayload() {
return payload;
}
public void setPayload(Payload payload) {
this.payload = payload;
}
public Server getServer() {
return server;
}
public void setServer(Server server) {
this.server = server;
}
public Settings getSettings() {
return settings;
}
public void setSettings(Settings settings) {
this.settings = settings;
}
public String getSignal() {
return signal;
}
public void setSignal(String signal) {
this.signal = signal;
}
public List<String> getSubscribers() {
return subscribers;
}
public void setSubscribers(List<String> subscribers) {
this.subscribers = subscribers;
}
public String getTask() {
return task;
}
public void setTask(String task) {
this.task = task;
}
public String getTimestamp() {
return timestamp;
}
public void setTimestamp(String timestamp) {
this.timestamp = timestamp;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
|
package com.tencent.mm.plugin.h.a.b.a;
import com.tencent.mm.plugin.h.a.b.a.b.c;
class b$a {
public c hhA = new c();
final /* synthetic */ b hhB;
public boolean hhv = false;
public double hhw = 0.0d;
public int hhx = 0;
public int hhy = 0;
public int hhz = 0;
public b$a(b bVar) {
this.hhB = bVar;
}
}
|
package com.example.quanlichitieu1;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageButton;
import android.widget.TextView;
import com.example.quanlichitieu1.data.DBManager;
import java.text.NumberFormat;
import java.util.Locale;
public class ViTienActivity extends AppCompatActivity implements View.OnClickListener {
TextView tvChiTieu,tvAnUong,tvTheThao,tvGiaiTri;
ImageButton imgViTien,imgAdd,imgChiTieu,btnAnUong,btnTheThao,btnGiaiTri;
public final DBManager dbManager = new DBManager(this);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_vi_tien);
Widget();
}
public void Widget(){
tvChiTieu = findViewById(R.id.tv_chi_tieu);
imgViTien = findViewById(R.id.img_btn_vi_tien);
imgViTien.setOnClickListener(this);
imgAdd = findViewById(R.id.img_btn_add);
imgAdd.setOnClickListener(this);
imgChiTieu = findViewById(R.id.img_btn_chi_tieu);
imgChiTieu.setOnClickListener(this);
btnAnUong = findViewById(R.id.btn_an_uong);
btnTheThao = findViewById(R.id.btn_the_thao);
btnGiaiTri = findViewById(R.id.btn_giai_tri);
btnAnUong.setOnClickListener(this);
btnTheThao.setOnClickListener(this);
btnGiaiTri.setOnClickListener(this);
tvAnUong = findViewById(R.id.tv_an_uong);
tvGiaiTri = findViewById(R.id.tv_giai_tri);
tvTheThao = findViewById(R.id.tv_the_thao);
tvAnUong.setText(HienThiTien(dbManager.getAnUong())+" VND");
tvGiaiTri.setText(HienThiTien(dbManager.getGiaiTri())+" VND");
tvTheThao.setText(HienThiTien(dbManager.getTheThao())+" VND");
tvChiTieu.setText("Σ"+HienThiTien(dbManager.getTongChiTieu())+" VND");
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.img_btn_chi_tieu:
Intent intent1 = new Intent(ViTienActivity.this,OptionActivity.class);
startActivity(intent1);
overridePendingTransition(R.anim.anim_enter_to_right,R.anim.anim_exit_to_right);
break;
case R.id.img_btn_add:
Intent intent2 = new Intent(ViTienActivity.this,AddActivity.class);
startActivity(intent2);
overridePendingTransition(R.anim.anim_enter_to_right,R.anim.anim_exit_to_right);
break;
case R.id.img_btn_vi_tien:
break;
case R.id.btn_an_uong:
Intent intent3 = new Intent(ViTienActivity.this,AnUongActivity.class);
startActivity(intent3);
overridePendingTransition(R.anim.anim_enter_to_down,R.anim.anim_exit_to_down);
break;
case R.id.btn_the_thao:
Intent intent4 = new Intent(ViTienActivity.this,TheThaoActivity.class);
startActivity(intent4);
overridePendingTransition(R.anim.anim_enter_to_down,R.anim.anim_exit_to_down);
break;
case R.id.btn_giai_tri:
Intent intent5 = new Intent(ViTienActivity.this,GiaiTriActivity.class);
startActivity(intent5);
overridePendingTransition(R.anim.anim_enter_to_down,R.anim.anim_exit_to_down);
break;
}
}
public String HienThiTien(int tien){
Locale localeVN= new Locale("vi","VN");
NumberFormat currencyVN = NumberFormat.getCurrencyInstance(localeVN);
String string = currencyVN.format(tien);
string = string.substring(1,string.length());
return string;
}
}
|
package com.jt.config;
import com.jt.pojo.User;
import com.jt.util.ObjectMapperUtil;
import com.jt.util.UserThreadLocal;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import redis.clients.jedis.JedisCluster;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 拦截器,实现用户权限判断
*/
@Component
public class UserInterceptor implements HandlerInterceptor {
@Autowired
private JedisCluster jedisCluster;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1.获取用户cookie信息
Cookie[] cookies = request.getCookies();
String ticket = null;
if (cookies.length > 0){
for (Cookie cookie : cookies){
if ("JT_TICKET".equals(cookie.getName())){
ticket = cookie.getValue();
break;
}
}
}
//判断取值是否有效
if (!StringUtils.isEmpty(ticket)){
String userJSON = jedisCluster.get(ticket);
if (!StringUtils.isEmpty(userJSON)){
User user = ObjectMapperUtil.toObject(userJSON, User.class);
UserThreadLocal.set(user);
return true;
}
}
response.sendRedirect("/user/login.html");
return false;
}
}
|
package spring;
public class Greeting {
private final int seq;
private final int batteryPercentage;
private final int batteryConnected;
private final double longtitude;
private final double latitude;
private final int cartId;
public Greeting(int seq, int batteryPercentage, int batteryConnected, double longtitude, double latitude, int cartId) {
this.seq = seq;
this.batteryPercentage = batteryPercentage;
this.batteryConnected = batteryConnected;
this.longtitude = longtitude;
this.latitude = latitude;
this.cartId = cartId;
}
public int getSeq() {
return seq;
}
public int getBatteryPercentage() {
return batteryPercentage;
}
public int getBatteryConnected() {
return batteryConnected;
}
public double getLongtitude() {
return longtitude;
}
public double getLatitude() {
return latitude;
}
public int getCartId() {
return cartId;
}
} |
package com.teebz.hrf.searchparsers;
import com.teebz.hrf.entities.Official;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
public class OfficialsXMLParser extends BaseParser {
public OfficialsXMLParser(InputStream in) {
super(in);
}
public ArrayList<Official> getAllOfficials() throws XmlPullParserException, IOException {
ArrayList<Official> officials = new ArrayList<Official>();
Parser.require(XmlPullParser.START_TAG, EmptyNamespace, "officials");
while (Parser.next() != XmlPullParser.END_TAG) {
if (Parser.getEventType() == XmlPullParser.END_DOCUMENT) {
break;
}
if (Parser.getEventType() != XmlPullParser.START_TAG) {
continue;
}
String name = Parser.getName();
// Starts by looking for the entry tag
if (name.equals("official")) {
officials.add(readOfficial());
} else {
skip();
}
}
return officials;
}
public Official readOfficial() throws XmlPullParserException, IOException {
Parser.require(XmlPullParser.START_TAG, EmptyNamespace, "official");
//We are at the starting "official" tag, move to the inside.
while (Parser.next() != XmlPullParser.END_TAG) {
if (Parser.getEventType() == XmlPullParser.START_TAG) {
break;
}
}
String number = getValueFromNodeAndContinue();
String name = getValueFromNodeAndContinue();
String league = getValueFromNodeAndContinue();
String memberSince = getValueFromNodeAndContinue();
String regSeasonCount = getValueFromNodeAndContinue();
String firstRegSeason = getValueFromNodeAndContinue();
String firstRegGame = getValueFromNodeAndContinue();
String playoffCount = getValueFromNodeAndContinue();
String firstPlayoffSeason = getValueFromNodeAndContinue();
String firstPlayoffGame = getValueFromNodeAndContinue();
return new Official(number, name, league, memberSince, regSeasonCount,
firstRegSeason, firstRegGame, playoffCount,
firstPlayoffSeason, firstPlayoffGame);
}
}
|
package com.tencent.mm.modelsimple;
import com.tencent.mm.ab.b;
import com.tencent.mm.ab.b.a;
import com.tencent.mm.ab.e;
import com.tencent.mm.ab.l;
import com.tencent.mm.network.k;
import com.tencent.mm.network.q;
import com.tencent.mm.protocal.c.btz;
import com.tencent.mm.protocal.c.bua;
import com.tencent.mm.protocal.c.cp;
import com.tencent.mm.sdk.platformtools.x;
import com.tencent.rtmp.TXLivePushConfig;
import java.util.LinkedList;
public final class aa extends l implements k {
private final b diG;
private e diJ;
public aa(String str, int i, LinkedList<cp> linkedList) {
x.i("MicroMsg.NetSceneTranslateLink", "ticket link = " + str + "; scene = " + i);
a aVar = new a();
aVar.dIG = new btz();
aVar.dIH = new bua();
aVar.uri = "/cgi-bin/mmbiz-bin/translatelink";
aVar.dIF = TXLivePushConfig.DEFAULT_MAX_VIDEO_BITRATE;
aVar.dII = 0;
aVar.dIJ = 0;
this.diG = aVar.KT();
btz btz = (btz) this.diG.dID.dIL;
btz.egr = str;
btz.scene = i;
btz.srr = linkedList;
}
public final int getType() {
return TXLivePushConfig.DEFAULT_MAX_VIDEO_BITRATE;
}
public final int a(com.tencent.mm.network.e eVar, e eVar2) {
this.diJ = eVar2;
return a(eVar, this.diG, this);
}
public final void a(int i, int i2, int i3, String str, q qVar, byte[] bArr) {
x.d("MicroMsg.NetSceneTranslateLink", "swap deep link with ticket onGYNetEnd:[%d,%d,%s]", new Object[]{Integer.valueOf(i2), Integer.valueOf(i3), str});
this.diJ.a(i2, i3, str, this);
}
public final String Rv() {
bua bua = (bua) this.diG.dIE.dIL;
if (bua == null) {
return null;
}
return bua.srs;
}
public final bua Rw() {
if (this.diG == null || this.diG.dIE.dIL == null) {
return null;
}
return (bua) this.diG.dIE.dIL;
}
}
|
package officehours05_25;
public class TicTacToe {
public static void main(String[] args) {
char[] game = {
'X', 'X', 'X',
'-', 'O', '-',
'-', 'O', '-'
};
}
/*
horizontal:
a[0] +a[1] +a[2]
a[3] +a[4] +a[5]
a[6] +a[7] +a[8]
vertical:
a[0] +a[3] +a[6]
a[1] +a[4] +a[7]
a[2] +a[5] +a[8]
Diagonal:
a[0] + a[4]+ a[8]
a[2] + a[4]+ a[6]
*/
public static String won(char[] x){
for(int i= 0, y =0; i < x.length;i++, y += 3){
String rows = "" + x[i] +x[y + 1] + x[y + 2];
String col = "" + x[i] +x[i + 3] + x[i + 6];
String dign = "";
if(i==0 ){
dign ="" + x[i] +x[i + 4] + x[i + 8];
}else if (i ==2){
dign ="" + x[i] +x[i + 2] + x[i + 4];
}
if(rows.equals("xxx") || col.equals("xxx")){
// winner ="Player x won";
// }else if("ooo") || col.equals("ooo"){
// winner ="Player o won";
}
}
return null;
}
}
|
public class App {
public static void main(String[] args){
System.out.println("This app scores scrabble");
}
}
|
package com.javabykiran;
//Register a new member(Pg of Login)
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.Test;
public class RegisterPgTest {
@Test
public void registerAnewMemberNameError()
{
System.setProperty("WebDriver.chrome.driver","ChromeDriver.exe");
WebDriver driver=new ChromeDriver();
driver.get("file:///C:/Users/rajat/Downloads/Selenium%20Softwares/Offline%20Website/Offline%20Website/index.html");
driver.findElement(By.id("name")).sendKeys("");
driver.findElement(By.id("mobile")).sendKeys("");
driver.findElement(By.id("email")).sendKeys("");
driver.findElement(By.id("password")).sendKeys("");
driver.findElement(By.xpath("/html/body/div/div[2]/form/div[5]/div/button")).click();
String error=driver.findElement(By.id("name_error")).getText();
String exp1="Please enter Name.";
driver.close();
Assert.assertEquals(error,exp1);
}
@Test
public void registerAnewMemberMobileError()
{
System.setProperty("WebDriver.chrome.driver","ChromeDriver.exe");
WebDriver driver=new ChromeDriver();
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
driver.findElement(By.id("name")).sendKeys("");
driver.findElement(By.id("mobile")).sendKeys("");
driver.findElement(By.id("email")).sendKeys("");
driver.findElement(By.id("password")).sendKeys("");
driver.findElement(By.xpath("/html/body/div/div[2]/form/div[5]/div/button")).click();
String error=driver.findElement(By.id("mobile_error")).getText();
String exp1="Please enter Mobile.";
driver.close();
Assert.assertEquals(error,exp1);
}
@Test
public void registerAnewMemberEmailError()
{
System.setProperty("WebDriver.chrome.driver","ChromeDriver.exe");
WebDriver driver=new ChromeDriver();
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
driver.findElement(By.id("name")).sendKeys("");
driver.findElement(By.id("mobile")).sendKeys("");
driver.findElement(By.id("email")).sendKeys("");
driver.findElement(By.id("password")).sendKeys("");
driver.findElement(By.xpath("/html/body/div/div[2]/form/div[5]/div/button")).click();
String error=driver.findElement(By.id("email_error")).getText();
String exp1="Please enter Email.";
driver.close();
Assert.assertEquals(error,exp1);
}
@Test
public void registerAnewMemberPassError()
{
System.setProperty("WebDriver.chrome.driver","ChromeDriver.exe");
WebDriver driver=new ChromeDriver();
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
driver.findElement(By.id("name")).sendKeys("");
driver.findElement(By.id("mobile")).sendKeys("");
driver.findElement(By.id("email")).sendKeys("");
driver.findElement(By.id("password")).sendKeys("");
driver.findElement(By.xpath("/html/body/div/div[2]/form/div[5]/div/button")).click();
String error=driver.findElement(By.id("password_error")).getText();
String exp1="Please enter Password.";
driver.close();
Assert.assertEquals(error,exp1);
}
@Test
public void varifyRegisterNewMemberHeading(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/index.html");
String actual=driver.findElement(By.xpath("/html/body/div/div[2]/a")).getText();
String expected= "Register a new membership";
driver.close();
Assert.assertEquals(actual,expected);
}
@Test
public void varifyRegisterHeading1(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
String actual=driver.findElement(By.xpath("/html/body/div/div[1]/a/b")).getText();
String expected= "Java By Kiran";
driver.close();
Assert.assertEquals(actual,expected);
}
@Test
public void varifyRegisterHeading2(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
String actual=driver.findElement(By.xpath("/html/body/div/div[2]/p")).getText();
String expected= "Register a new membership";
driver.close();
Assert.assertEquals(actual,expected);
}
@Test
public void checkText(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
String actual=driver.findElement(By.xpath("/html/body/div/div[2]/a")).getText();
String expected= "I already have a membership";
driver.close();
Assert.assertEquals(actual,expected);
}
@Test
public void checkButtonText(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
String actual=driver.findElement(By.xpath("/html/body/div/div[2]/form/div[5]/div/button")).getText();
String expected= "Sign In";
driver.close();
Assert.assertEquals(actual,expected);
}
@Test
public void alreadyRegisteredMember(){
System.setProperty("webdriver.chrome.driver", "chromeDriver.exe");
WebDriver driver=new ChromeDriver();//open browser
driver.get("file:///E:/Softwares/Selenium%20Softwares/Offline%20Website/Offline%20Website/pages/examples/register.html");
driver.findElement(By.xpath("/html/body/div/div[2]/a")).click();
String actual=driver.getTitle();
String expected= "JavaByKiran | Log in";
driver.close();
Assert.assertEquals(actual,expected);
}
}
|
package com.notet.activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.TextView;
import com.note.databasehandler.DabaseHandler;
import com.note.model.Notes;
import java.io.IOException;
public class EditNoteActivity extends AddNoteActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
public void getControls() {
super.getControls();
try {
loadData();
} catch (IOException e) {
e.printStackTrace();
}
}
private void loadData() throws IOException {
// load Titie and content and image Node edit
mDabaseHandler = new DabaseHandler(this);
Bundle bd = getIntent().getExtras();
if (bd != null){
int id = bd.getInt("id");
Notes iNote = (Notes) mDabaseHandler.getNote(id);
// set text
mTxtTitle.setText(iNote.getTitle());
mTxtContent.setText(iNote.getContent());
//mLlAddNote.setBackgroundColor(Color.BLUE);
// TODO set background
mColor = Integer.parseInt(iNote.getBackground());
//mLlAddNote.setBackgroundColor(mColor);
int[] arrColor = {getResources().getColor(R.color.color_white), getResources().getColor(R.color.color_yellow),
getResources().getColor(R.color.color_green), getResources().getColor(R.color.color_blue)};
switch (mColor) {
case RESULT_COLOR_WHITE:
mLlAddNote.setBackgroundColor(arrColor[0]);
break;
case RESULT_COLOR_YELLOW:
mLlAddNote.setBackgroundColor(arrColor[1]);
break;
case RESULT_COLOR_GREEN:
mLlAddNote.setBackgroundColor(arrColor[2]);
break;
case RESULT_COLOR_BLUE:
mLlAddNote.setBackgroundColor(arrColor[3]);
break;
default:
mLlAddNote.setBackgroundColor(arrColor[0]);
break;
}
// set alarm
if (!iNote.getAlarm().toString().equals(" ")){
mLlAlarm.setEnabled(true);
mLlAlarm.setVisibility(View.VISIBLE);
TextView text = (TextView)findViewById(R.id.txtVgetAlarm);
text.setText("the Note has set Alarm : "+iNote.getAlarm());
Log.d("Visible linnear layout", "visible");
spinerDropDown();
mTxtAlarm.setVisibility(View.GONE);
mStrAlarm = iNote.getAlarm();
//Toast.makeText(getBaseContext(),iNote.getAlarm(),Toast.LENGTH_LONG).show();
//mSpDate.setSelection(0);
//mSpTime.setSelection(0);
}
// Load Images
if(!iNote.getImages().equals("")){
loadImages();
}
}
}
private void loadImages() throws IOException {
Bundle bd = getIntent().getExtras();
if (bd != null) {
int id = bd.getInt("id");
Notes iNote = (Notes) mDabaseHandler.getNote(id);
// get string bitmap
// demo
String path = iNote.getImages();
//String s = "/storage/emulated/0/Android/data/com.notet.activity/files/Pictures/JPEG_20170308_201643_160484423.jpg";
//Bitmap bmp = readBitmapFile(s);
String[] tokenPath = path.split("tachchuoi");
for(String token: tokenPath){
if(token.length()!=0){
Bitmap bitmap = BitmapFactory.decodeFile(token);
Bitmap resize = Bitmap.createScaledBitmap(bitmap, 300, 250, true);
Log.d("insert photo","source "+bitmap.toString());
mBitmapArrayList.add(bitmap);
mGridImagesAdapter.addItem(resize,token);
//mGridImagesAdapter.addItem(bitmap);
mGridImagesAdapter.notifyDataSetChanged();
mGridView.setAdapter(mGridImagesAdapter);
}
}
}
}
/**
* create bitmap from string path
* @param path
* @return
*/
public Bitmap readBitmapFile(String path){
return BitmapFactory.decodeFile(path);
}
@Override
public void addNote() {
Bundle bd = getIntent().getExtras();
int id = bd.getInt("id");
Log.d("eidt mNote ", "id max " + id);
insertNote(id);
}
public void deleteNote(){
Bundle bd = getIntent().getExtras();
int id = bd.getInt("id");
mDabaseHandler.deleteNotes(id);
Log.d("Edit mNote", "deleted node id = "+id);
Intent i = new Intent(EditNoteActivity.this,MainActivity.class);
startActivity(i);
}
@Override
public void insert(Notes notes) {
try {
mDabaseHandler.updateNotes(notes);
mDabaseHandler.close();
Log.d("EditNoteActivity", "edit mNote success.." + mStrAlarm);
} catch (Exception e) {
Log.d("EditNoteActivity", "edit new a mNote errorr..." + e.toString());
}
// set alarm for this item.
if (!mStrAlarm.toString().equals(" ")) {
Log.d("EditNoteActivity", "edit mNote mStrAlarm.." + mStrAlarm);
startAlert(notes.getID(), mStrAlarm);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.eidt_note, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
switch (id) {
case R.id.action_insertphoto:
InsertPhoto();
break;
case R.id.action_setbackground:
SetBacground();
break;
case R.id.action_savenote:
SaveNote();
break;
case R.id.action_deletenote:
deleteNote();
break;
default:
break;
}
// TODO create option menu share
return true;
}
}
|
package com.example.administrator.study;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
public class Main2Activity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
Button bt2=(Button)findViewById(R.id.bt2);
Intent t=getIntent();
final String data=t.getStringExtra("extra_data");
bt2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(Main2Activity.this,data,Toast.LENGTH_LONG).show();
}
});
}
}
|
package src.test.java.pages;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import src.test.java.base.Base;
public class IdentityPage extends Base{
By succesfullyUpdatedMsg = By.xpath("/html/body/div/div[2]/div/div[3]/div/div/p");
public IdentityPage(WebDriver driver) {
super(driver);
// TODO Auto-generated constructor stub
}
public Boolean isDisplayedSuccesfullyUpdatedMsg() {
waitToBeVisible(succesfullyUpdatedMsg);
return isDisplayed(succesfullyUpdatedMsg);
}
}
|
package com.architech.ziarkowski.configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import java.util.NoSuchElementException;
@Configuration
public class ConfigurationProvider {
public static final int DEFAULT_MINIMAL_USER_NAME_LENGTH = 5;
public static final int DEFAULT_MAXIMAL_USER_NAME_LENGTH = 0;
public static final String DEFAULT_USER_NAME_PATTERN = "^[a-zA-Z0-9]*$";
public static final String USER_NAME_MINIMAL_LENGTH_CONFIGURATION_PATH = "profileCriteria.userName.minimalLength";
public static final String USER_NAME_MAXIMAL_LENGTH_CONFIGURATION_PATH = "profileCriteria.userName.maximalLength";
public static final String USER_NAME_PATTERN_CONFIGURATION_PATH = "profileCriteria.userName.pattern";
private static final String PASSWORD_MINIMAL_LENGTH_CONFIGURATION_PATH = "profileCriteria.password.minimalLength";
private static final String PASSWORD_MAXIMAL_LENGTH_CONFIGURATION_PATH = "profileCriteria.password.maximalLength";
private static final String PASSWORD_PATTERN_CONFIGURATION_PATH = "profileCriteria.password.pattern";
private static final int DEFAULT_MINIMAL_PASSWORD_LENGTH = 8;
private static final int DEFAULT_MAXIMAL_PASSWORD_LENGTH = 0;
private static final String DEFAULT_PASSWORD_PATTERN = "^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[A-Za-z\\d]*$";
private static final String EXCEPTION_MESSAGE_PATH = "messages.%s";
private static final String NO_DATABASE_MODE_PATH = "system.noDatabaseMode";
private static Logger logger = LoggerFactory.getLogger(ConfigurationProvider.class);
private XMLConfiguration xmlConfiguration;
private String configurationFile;
@PostConstruct
public void initializeConfiguration() {
try {
try {
final String customConfigurationDirectoryPath = System.getenv("USER_REPOSITORY_CUSTOM_CONFIG");
readConfiguration(customConfigurationDirectoryPath + configurationFile);
} catch (ConfigurationException e) {
readConfiguration(configurationFile);
}
} catch (ConfigurationException e) {
logger.warn("Unable to read configuration file - set a default values. Message: {}", e.getMessage());
}
}
private void readConfiguration(String configurationFile) throws ConfigurationException {
this.xmlConfiguration = new XMLConfiguration(configurationFile);
xmlConfiguration.setThrowExceptionOnMissing(true);
}
@Required
@Value ("service-config.xml")
public void setConfigurationFile(String configurationFile) {
this.configurationFile = configurationFile;
}
public int getMinimalUserNameLength() {
return getConfiguredValue(USER_NAME_MINIMAL_LENGTH_CONFIGURATION_PATH, DEFAULT_MINIMAL_USER_NAME_LENGTH);
}
public int getMaximalUserNameLength() {
return getConfiguredValue(USER_NAME_MAXIMAL_LENGTH_CONFIGURATION_PATH, DEFAULT_MAXIMAL_USER_NAME_LENGTH);
}
public String getUserNamePattern() {
return getConfiguredValue(USER_NAME_PATTERN_CONFIGURATION_PATH, DEFAULT_USER_NAME_PATTERN);
}
public int getMinimalPasswordLength() {
return getConfiguredValue(PASSWORD_MINIMAL_LENGTH_CONFIGURATION_PATH, DEFAULT_MINIMAL_PASSWORD_LENGTH);
}
public int getMaximalPasswordLength() {
return getConfiguredValue(PASSWORD_MAXIMAL_LENGTH_CONFIGURATION_PATH, DEFAULT_MAXIMAL_PASSWORD_LENGTH);
}
public String getPasswordPattern() {
return getConfiguredValue(PASSWORD_PATTERN_CONFIGURATION_PATH, DEFAULT_PASSWORD_PATTERN);
}
public String getExceptionMessage(Class c) {
return getConfiguredValue(String.format(EXCEPTION_MESSAGE_PATH, c.getSimpleName()), "");
}
public boolean noDatabaseModeEnabled() {
return getConfiguredValue(NO_DATABASE_MODE_PATH, true);
}
private int getConfiguredValue(String path, int defaultValue) {
try {
return xmlConfiguration != null ? xmlConfiguration.getInt(path) : defaultValue;
} catch (NoSuchElementException e) {
logger.warn("Unable to find configuration value for: {}. Returning a default value.");
}
return defaultValue;
}
private String getConfiguredValue(String path, String defaultValue) {
try {
return xmlConfiguration != null ? xmlConfiguration.getString(path) : defaultValue;
} catch (NoSuchElementException e) {
logger.warn("Unable to find configuration value for: {}. Returning a default value.");
}
return defaultValue;
}
private boolean getConfiguredValue(String path, boolean defaultValue) {
try {
return xmlConfiguration != null ? xmlConfiguration.getBoolean(path) : defaultValue;
} catch (NoSuchElementException e) {
logger.warn("Unable to find configuration value for: {}. Returning a default value.");
}
return defaultValue;
}
}
|
package com.legalzoom.api.test.dto;
import java.util.ArrayList;
import java.util.List;
/**
*
hmaheshwari
Jan 6, 2016
2:37:20 PM
*/
public class CreateCustomersDTO implements DTO {
private CustomersDTO customer;
private String message;
// private ContactDTO contact;
private List<ContactDTO> contacts = null;
public CustomersDTO getCustomer() {
return customer;
}
public void setCustomer(CustomersDTO customer) {
this.customer = customer;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public void setContacts(List<ContactDTO> contacts){
this.contacts = contacts;
}
}
|
package com.mes.old.meta;
// Generated 2017-5-22 1:25:24 by Hibernate Tools 5.2.1.Final
/**
* KVelocitySwip generated by hbm2java
*/
public class KVelocitySwip implements java.io.Serializable {
private KVelocitySwipId id;
public KVelocitySwip() {
}
public KVelocitySwip(KVelocitySwipId id) {
this.id = id;
}
public KVelocitySwipId getId() {
return this.id;
}
public void setId(KVelocitySwipId id) {
this.id = id;
}
}
|
package com.tencent.mm.plugin.appbrand.config;
import com.tencent.mm.a.g;
import com.tencent.mm.g.a.bc;
import com.tencent.mm.sdk.b.b;
import com.tencent.mm.sdk.b.c;
import com.tencent.mm.sdk.platformtools.bi;
import com.tencent.mm.sdk.platformtools.j;
public final class e extends c<bc> {
public e() {
this.sFo = bc.class.getName().hashCode();
}
public final /* synthetic */ boolean a(b bVar) {
bc bcVar = (bc) bVar;
if (bcVar.bIB.bIC == 38) {
int i = bcVar.bIB.bID;
int i2 = bcVar.bIB.bIE;
String str = bcVar.bIB.filePath;
if (!bi.oW(str) || com.tencent.mm.a.e.cn(str)) {
boolean z;
String adX = AppBrandGlobalSystemConfig.adX();
if (com.tencent.mm.a.e.cn(adX)) {
String cu = g.cu(str);
z = (bi.oW(cu) || cu.equals(g.cu(adX))) ? false : true;
} else {
z = true;
}
if (z) {
AppBrandGlobalSystemConfig.adW();
j.fN(str, adX);
com.tencent.mm.pluginsdk.g.a.a.b.c.ccr().ae(38, i, i2);
}
}
}
return true;
}
}
|
package com.ricettadem.services.dpcm;
import com.ricettadem.components.SOAPClientComponent;
import com.ricettadem.helper.CsvHelper;
import com.ricettadem.helper.EncryptDecryptHelper;
import com.ricettadem.model.dpcm.Prescrizione;
import com.ricettadem.model.dpcm.RicettaDpcm;
import com.ricettadem.model.dpcm.RicettaDpcmInvioResponse;
import com.ricettadem.model.dpcm.RicettaMir;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
@Service
public class RicettaMirService {
private static final Logger logger = LoggerFactory.getLogger(RicettaMirService.class);
private static final String ESITO_OK = "000";
@Value("${csv.delimiter}")
private String delimiter;
@Value("${dpcm.ricetta.num-campi}")
private Integer ricettaDpcmNumCampi;
@Value("${dpcm.ricetta.testata-num-campi}")
private Integer ricettaDpcmTestataNumCampi;
@Value("${dpcm.ricetta.prescrizione-num-campi}")
private Integer ricettaDpcmPrescrizioneNumCampi;
@Value("${ws.uri.dpcm.invio-ricetta}")
private String uriInvioRicettaDpcm;
@Value("${dpcm.ricetta.request.file-path}")
private String ricettaDpcmFilePath;
@Value("${dpcm.ricetta.response.file-path}")
private String ricettaDpcmResponseFilePath;
@Value("${dpcm.ricetta.tmp-folder-path}")
private String ricettaDpcmTmpFolderPath;
@Value("${dpcm.ricetta.tmp-folder-delete}")
private String ricettaDpcmDeleteTmpFolder;
@Value("${sac.certificate.file-path}")
private String sacCertificateFilePath;
@Autowired
private SOAPClientComponent soapClientComponent;
public void invia() throws Exception{
logger.info("INVIO RICETTA DPCM DEMATERIALIZZATA");
logger.info("Parsing the file...");
RicettaMir ricettaMir = CsvHelper.readRicettaDpcmCsv(ricettaDpcmFilePath, delimiter, ricettaDpcmTestataNumCampi, ricettaDpcmNumCampi, ricettaDpcmPrescrizioneNumCampi);
logger.info("Ricetta DPCM retrieved from file: " + ricettaMir.toString());
logger.info("Creating the xml file...");
StringWriter stringWriter = new StringWriter();
XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(stringWriter);
xmlStreamWriter.writeStartElement("RicetteMIR");
xmlStreamWriter.writeStartElement("Testata");
xmlStreamWriter.writeStartElement("PinCode");
xmlStreamWriter.writeCharacters(EncryptDecryptHelper.encrypt(ricettaMir.getTestata().getPinCode(), sacCertificateFilePath));
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("TipoInvio");
xmlStreamWriter.writeCharacters(ricettaMir.getTestata().getTipoInvio());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Testata1");
xmlStreamWriter.writeCharacters(ricettaMir.getTestata().getTestata1());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Testata2");
xmlStreamWriter.writeCharacters(ricettaMir.getTestata().getTestata2());
xmlStreamWriter.writeEndElement();
// chiusura 'Testata'
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("RicettaI");
RicettaDpcm ricettaDpcm = ricettaMir.getRicetta();
xmlStreamWriter.writeStartElement("Bar1");
xmlStreamWriter.writeCharacters(ricettaDpcm.getBar1());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Bar2");
xmlStreamWriter.writeCharacters(ricettaDpcm.getBar2());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Altro");
xmlStreamWriter.writeCharacters(ricettaDpcm.getAltro());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("NoteInvio");
xmlStreamWriter.writeCharacters(ricettaDpcm.getNoteInvio());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("CodiceAss");
xmlStreamWriter.writeCharacters(EncryptDecryptHelper.encrypt(ricettaDpcm.getCodAssistito(), sacCertificateFilePath));
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("TipoPrescrizione");
xmlStreamWriter.writeCharacters(ricettaDpcm.getTipoPrescrizione());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("CodEsenzione");
xmlStreamWriter.writeCharacters(ricettaDpcm.getCodEsenzione());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("NonEsente");
xmlStreamWriter.writeCharacters(ricettaDpcm.getNonEsente());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Reddito");
xmlStreamWriter.writeCharacters(ricettaDpcm.getReddito());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("CodiceDiagnosi");
xmlStreamWriter.writeCharacters(ricettaDpcm.getCodDiagnosi());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DescrizioneDiagnosi");
xmlStreamWriter.writeCharacters(ricettaDpcm.getDescrDiagnosi());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("TotPezzi");
xmlStreamWriter.writeCharacters(ricettaDpcm.getTotPezzi());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("TipoRic");
xmlStreamWriter.writeCharacters(ricettaDpcm.getTipoRic());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DataCompilazione");
xmlStreamWriter.writeCharacters(ricettaDpcm.getDataCompilazione());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("TipoVisita");
xmlStreamWriter.writeCharacters(ricettaDpcm.getTipoVisita());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DispReg");
xmlStreamWriter.writeCharacters(ricettaDpcm.getDispReg());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("ProvAssistito");
xmlStreamWriter.writeCharacters(ricettaDpcm.getProvAssistito());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("AslAssistito");
xmlStreamWriter.writeCharacters(ricettaDpcm.getAslAssistito());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("IndicazionePresc");
xmlStreamWriter.writeCharacters(ricettaDpcm.getIndicazionePrescrizione());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("ClassePriorita");
xmlStreamWriter.writeCharacters(ricettaDpcm.getClassePriorita());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("StatoEstero");
xmlStreamWriter.writeCharacters(ricettaDpcm.getStatoEstero());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("IstituzCompetente");
xmlStreamWriter.writeCharacters(ricettaDpcm.getIstituzCompetente());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("NumIdentPers");
xmlStreamWriter.writeCharacters(ricettaDpcm.getNumIdentPers());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("NumIdentTess");
xmlStreamWriter.writeCharacters(ricettaDpcm.getNumIdentTess());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DataNascitaEstero");
xmlStreamWriter.writeCharacters(ricettaDpcm.getDataNascitaEstero());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DataScadTessera");
xmlStreamWriter.writeCharacters(ricettaDpcm.getDataScadTessera());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Ricetta1");
xmlStreamWriter.writeCharacters(ricettaDpcm.getRicetta1());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Ricetta2");
xmlStreamWriter.writeCharacters(ricettaDpcm.getRicetta2());
xmlStreamWriter.writeEndElement();
List<Prescrizione> prescrizioni = ricettaMir.getPrescrizioni();
if(prescrizioni != null && !prescrizioni.isEmpty()){
for(Prescrizione prescrizione: prescrizioni){
xmlStreamWriter.writeStartElement("Prescrizione");
xmlStreamWriter.writeStartElement("CodProdPrest");
xmlStreamWriter.writeCharacters(prescrizione.getCodProdPrest());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("DescrProdPrest");
xmlStreamWriter.writeCharacters(prescrizione.getDescrProdPrest());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("NotaProd");
xmlStreamWriter.writeCharacters(prescrizione.getNotaProd());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Quantita");
xmlStreamWriter.writeCharacters(prescrizione.getQuantita());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Prescrizione1");
xmlStreamWriter.writeCharacters(prescrizione.getPrescrizione1());
xmlStreamWriter.writeEndElement();
xmlStreamWriter.writeStartElement("Prescrizione2");
xmlStreamWriter.writeCharacters(prescrizione.getPrescrizione2());
xmlStreamWriter.writeEndElement();
// chiusura 'Prescrizione'
xmlStreamWriter.writeEndElement();
}
}
// chiusura 'RicettaI'
xmlStreamWriter.writeEndElement();
// chiusura 'RicetteMIR'
xmlStreamWriter.writeEndElement();
xmlStreamWriter.flush();
xmlStreamWriter.close();
String xmlString = stringWriter.getBuffer().toString();
stringWriter.close();
xmlString = transformToPrettyPrint(xmlString);
//System.out.println(transformToPrettyPrint(xmlString));
String fileName = System.currentTimeMillis() + "_Venza_Windoc";
String xmlFilePath = ricettaDpcmTmpFolderPath + "/" + fileName + ".xml";
File xmlFile = new File(xmlFilePath);
if(xmlFile.exists()){
try{
xmlFile.delete();
} catch(Exception e){
logger.info("Unable to delete the file '" + xmlFilePath + "'");
}
}
try (PrintWriter out = new PrintWriter(xmlFile)) {
out.println(xmlString);
}
logger.info("File xml successfully created");
logger.info("Creating the zip file...");
String zipFilePath = ricettaDpcmTmpFolderPath + "/" + fileName + ".zip";
File zipFile = new File(zipFilePath);
if(zipFile.exists()){
try{
zipFile.delete();
} catch(Exception e){
logger.info("Unable to delete the file '" + zipFilePath + "'");
}
}
FileOutputStream fos = null;
FileInputStream fis = null;
ZipOutputStream zipOut = null;
try{
fos = new FileOutputStream(zipFilePath);
zipOut = new ZipOutputStream(fos);
File fileToZip = new File(xmlFilePath);
fis = new FileInputStream(fileToZip);
ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
zipOut.putNextEntry(zipEntry);
byte[] bytes = new byte[1024];
int length;
while((length = fis.read(bytes)) >= 0) {
zipOut.write(bytes, 0, length);
}
// cancello il file xml
if(xmlFile.exists()){
try{
xmlFile.delete();
} catch(Exception e){
logger.info("Unable to delete the file '" + xmlFilePath + "'");
}
}
} catch(Exception e){
logger.error("Error creating the zip file", e);
throw e;
} finally{
if(zipOut != null){
zipOut.close();
}
if(fis != null){
fis.close();
}
if(fos != null){
fos.close();
}
}
logger.info("File zip successfully created");
logger.info("Performing the soap request...");
RicettaDpcmInvioResponse ricettaDpcmInvioResponse = soapClientComponent.sendInvioRicettaDpcm(fileName + ".zip", new File(zipFilePath));
logger.info("Soap request successfully performed");
// cancello il file zip
if(ricettaDpcmDeleteTmpFolder.equalsIgnoreCase("true")){
if(zipFile.exists()){
try{
zipFile.delete();
} catch(Exception e){
logger.info("Unable to delete the file '" + xmlFilePath + "'");
}
}
}
logger.info("Creating the response file...");
String codiceEsitoOutput = "Codice Esito: " + ricettaDpcmInvioResponse.getCodiceEsito();
String protocolloSACOutput = "Protocollo SAC: " + ricettaDpcmInvioResponse.getProtocolloSAC();
String dataAccoglienzaOutput = "Data Accoglienza: " + ricettaDpcmInvioResponse.getDataAccoglienza();
String nomeFileAllegatoOutput = "Nome File Allegato: " + ricettaDpcmInvioResponse.getNomeFileAllegato();
String dimensioniFileAllegatoOutput = "Dimensioni File Allegato: " + ricettaDpcmInvioResponse.getDimensioneFileAllegato();
String descrizioneEsitoOutput = "Descrizione Esito: " + ricettaDpcmInvioResponse.getDescrizioneEsito();
BufferedWriter bw = null;
try{
File responseFile = new File(ricettaDpcmResponseFilePath);
if(responseFile != null && responseFile.exists()){
responseFile.delete();
}
FileWriter fw = new FileWriter(responseFile, true);
bw = new BufferedWriter(fw);
bw.write(codiceEsitoOutput);
bw.newLine();
bw.write(protocolloSACOutput);
bw.newLine();
bw.write(dataAccoglienzaOutput);
bw.newLine();
bw.write(nomeFileAllegatoOutput);
bw.newLine();
bw.write(dimensioniFileAllegatoOutput);
bw.newLine();
bw.write(descrizioneEsitoOutput);
bw.newLine();
} catch(Exception e){
bw.close();
logger.error("Error creating response file", e);
throw e;
} finally{
bw.close();
}
logger.info("Response file successfully created");
}
private String transformToPrettyPrint(String xml) throws Exception{
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
Writer out = new StringWriter();
t.transform(new StreamSource(new StringReader(xml)), new StreamResult(out));
return out.toString();
}
}
|
package lesson25.Ex5;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Run {
public static void main(String[] args) {
int choice = 0;
String fileName = "EMP.TXT";
Scanner input = new Scanner(System.in);
ArrayList<Employee> employees = new ArrayList<>(readFromFile(fileName));
var previousData = employees.size();
if (previousData > 0) {
setLastId(employees.get(employees.size() - 1).getIdEmp()); //lấy ra id của thằng cuối cùng
}
do {
System.out.println("===============================");
System.out.println("1. Thêm một nhân viên");
System.out.println("2. Hiển thị thông tin nhân viên");
System.out.println("3. Tìm nhân viên theo tên");
System.out.println("4. Tìm nhân viên có mức lương lớn hơn mức lương định mức");
System.out.println("5. Tìm giám đốc theo nhiệm kỳ");
System.out.println("6. Xóa nhân viên theo mã cho trước");
System.out.println("7. Tính lương và thưởng cho nhân viên");
System.out.println("8. Hiển thị bảng lương");
System.out.println("9. Ghi danh sách nhân viên vào file EMP.txt");
System.out.println("0. Thoát chương trình");
System.out.println("=========>>> Nhập lựa chọn <<<=========");
choice = Integer.parseInt(input.nextLine());
switch (choice) {
case 0:
showNotify("Đã thoát chương trình");
break;
case 1:
System.out.println("Chọn (1) thêm nhân viên, (2) thêm giám đốc.");
int pick = Integer.parseInt(input.nextLine());
if (pick == 1) {
var newEmployee = createEmp(input);
employees.add(newEmployee);
showNotify("Thêm thành công một nhân viên");
} else if (pick == 2) {
var newManager = createMng(input);
employees.add(newManager);
showNotify("Thêm thành công một giám đốc");
} else {
showNotify("Sai cú pháp, vui lòng chọn lại ...");
}
break;
case 2:
if (employees.size() > 0) {
System.out.println("Danh sách nhân viên và giám đốc");
showEmp(employees);
} else {
showNotify("Danh sách nhân viên rỗng");
}
break;
case 3:
if (employees.size() > 0) {
System.out.println("Nhập tên nhân viên: ");
var name = input.nextLine();
var result = searchByName(name, employees);
if (result.size() > 0) {
System.out.println("Có " + result.size() + " kết quả cho " + name);
showEmp(result);
} else {
showNotify("Không có kết quả cho " + name);
}
} else {
showNotify("Danh sách nhân viên trống");
}
break;
case 4:
if (employees.size() > 0) {
System.out.println("Nhập mức lương định mức");
var amount = Float.parseFloat(input.nextLine());
var result = searchByWages(amount, employees);
if (result.size() > 0) {
System.out.println("Có " + result.size() + " nhân viên có mức lương lớn hơn " + amount);
showEmp(result);
} else {
showNotify("Không có kết quả");
}
} else {
showNotify("Danh sách nhân viên trống...");
}
break;
case 5:
if (employees.size() > 0) {
System.out.println("Năm bắt đầu nhiệm kỳ: ");
var startYear = Integer.parseInt(input.nextLine());
System.out.println("Năm kết thúc nhiệm kỳ: ");
var endYear = Integer.parseInt(input.nextLine());
var result = findManagerByTerm(startYear, endYear, employees);
if (result.size() > 0) {
System.out.println("Có " + result.size() + " kết quả");
showEmp(result);
} else {
showNotify("Không có kết quả...");
}
} else {
showNotify("Danh sách nhân viên trống...");
}
break;
case 6:
if (employees.size() > 0) {
System.out.println("Mã nhân viên cần xóa: ");
var idremove = input.nextLine();
var isDelete = removeById(idremove, employees);
if (isDelete) {
System.out.println("Xóa thành công nhân viên " + idremove);
} else {
showNotify("Thao tác không thành công, vui lòng thực hiện lại");
}
} else {
showNotify("Danh sách nhân viên trống...");
}
break;
case 7: //tính lương và thưởng
if (employees.size() > 0) {
calcularWagesMethod(employees);
calcularBonusMethod(employees);
showNotify("Tính toán thành công");
} else {
showNotify("Danh sách nhân viên trống");
}
break;
case 8: //hiển thị bảng lương
if (employees.size() > 0) {
showNotify("Bảng lương tháng này");
showPayroll(employees);
} else {
showNotify("Danh sách nhân viên trống");
}
break;
case 9:
if (employees.size() > 0) {
var isSuccess = writeToFile(employees, fileName);
if (isSuccess) {
showNotify("Ghi file thành công");
} else {
showNotify("ghi file thất bại");
}
} else {
showNotify("Danh sách nhân viên trống...");
}
break;
default:
showNotify("Sai cú pháp, vui lòng nhập lại trong khoảng [0,9]");
break;
}
} while (choice != 0);
}
/**
* đọc ra bộ nhớ đệm rồi thì giờ ghi vào file trong ổ chứa
* @param employees
* @return
*/
private static boolean writeToFile(ArrayList<Employee> employees, String fileName) {
try {
PrintWriter printWriter = new PrintWriter(fileName);
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
for (var emp : employees) {
if (emp instanceof Manager) {
printWriter.printf("%s - %s - %s - %s - %s - %s - %s - %s - %f - %f - %d - %f - %f - %s - %s\n",
emp.getIdCard(), emp.getFullName(), emp.getAddress(), dateFormat.format(emp.getDayOfBirth()),
emp.getEmail(), emp.getPhoneNumber(), emp.getIdEmp(), emp.getPosition(), emp.getBasicWages(),
emp.getExperience(), emp.getDayInTheMonth(), emp.getBonus(), emp.getReceiveWages(),
dateFormat.format(((Manager) emp).getStartTerm()),
dateFormat.format(((Manager) emp).getEndTerm()));
} else {
printWriter.printf("%s - %s - %s - %s - %s - %s - %s - %s - %f - %f - %d - %f - %f\n",
emp.getIdCard(), emp.getFullName(), emp.getAddress(), dateFormat.format(emp.getDayOfBirth()),
emp.getEmail(), emp.getPhoneNumber(), emp.getIdEmp(), emp.getPosition(), emp.getBasicWages(),
emp.getExperience(), emp.getDayInTheMonth(), emp.getBonus(), emp.getReceiveWages());
}
}
printWriter.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* phương thức tách lấy phần số của mã nhân viên cuối cùng trong danh sách có sẵn
* rồi sét tiếp cho nhân viên mới tiếp theo
* @param idEmp mã nhân viên cuối cùng của danh sách cũ có sẵn
*/
private static void setLastId(String idEmp) {
var lastIdStr = idEmp.substring(3); //lấy ra phần số
var lastIdInt = Integer.parseInt(lastIdStr); //chuyển chuỗi số (dạng String) vừa tách thành dạng chữ số
Employee.setNextId(lastIdInt + 1);
}
/**
* phương thức đọc ra dữ liệu trước đó trong file (nếu có)
* @param fileName tên file
* @return trả về danh sách dữ liệu trong file
*/
private static ArrayList<Employee> readFromFile(String fileName) {
ArrayList<Employee> emps = new ArrayList<>();
var file = new File(fileName);
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
try {
file.createNewFile();
var input = new Scanner(file);
while (input.hasNextLine()) {
var line = input.nextLine();
String[] data = line.split(" - "); //phân tách chuỗi thành các phần tử trong mảng và cách nhau bởi dấu -
Employee employee = createEmpFromData(data);
if (employee != null) {
emps.add(employee);
}
}
input.close();
} catch (IOException e) {
e.printStackTrace();
}
return emps;
}
/**
* tạo mới mới thông tin của nhân viên
* @param data dữ liệu truyền vào sau khi đọc file
* @return trả về đối tượng được tham chiếu đến bởi Employee
*/
private static Employee createEmpFromData(String[] data) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
var idCard = data[0];
var fullName = data[1];
var address = data[2];
Date dayOfBirth = null;
try {
dayOfBirth = dateFormat.parse(data[3]);
} catch (ParseException e) {
e.printStackTrace();
}
var email = data[4];
var phone = data[5];
var idEMP = data[6];
var posi = data[7];
var basicW = Float.parseFloat(data[8]);
var exp = Float.parseFloat(data[9]);
var dayInMonth = Integer.parseInt(data[10]);
var bonus = Float.parseFloat(data[11]);
var receiveW = Float.parseFloat(data[12]);
Date startDay = null;
Date endDay = null;
if (data.length > 13) { //hiểu là nếu vào trường hợp giám đốc thì chuỗi sẽ có 15 phần tử, còn emp chỉ có 13 thôi
try {
startDay = dateFormat.parse(data[13]);
endDay = dateFormat.parse(data[14]);
} catch (ParseException e) {
e.printStackTrace();
}
Manager manager = new Manager(idCard, fullName, address, dayOfBirth, email, phone,
idEMP, posi, basicW, exp, dayInMonth, bonus, receiveW, startDay, endDay);
return manager;
}
Employee employee = new Employee(idCard, fullName, address, dayOfBirth, email, phone,
idEMP, posi, basicW, exp, dayInMonth, bonus, receiveW);
return employee;
}
/**
* hiển thị bảng lương
* @param employees
*/
private static void showPayroll(ArrayList<Employee> employees) {
System.out.printf("%-17s %-18s %-21s %-10s %-15s\n",
"Mã nhân viên", "Họ và tên", "Số ngày làm việc", "Thưởng", "Tổng lương");
for (var emp : employees) {
System.out.printf("%-17s %-18s %-21d %-10.2f %-15.2f\n",
emp.getIdEmp(), emp.getFullName(), emp.getDayInTheMonth(),
emp.getBonus(), emp.getReceiveWages());
}
}
/**
* phương thức tính thưởng cho nhân viên
* @param employees
*/
private static void calcularBonusMethod(ArrayList<Employee> employees) {
for (int i = 0; i < employees.size(); i++) {
employees.get(i).calcularBonus();
}
}
/**
* phương thức tính lương cho nhân viên
* @param employees
*/
private static void calcularWagesMethod(ArrayList<Employee> employees) {
for (int i = 0; i < employees.size(); i++) {
employees.get(i).calcularReceiveWage(); //lương thực nhận
}
}
/**
* xóa nhân viên bằng mã id
*/
private static boolean removeById(String idremove, ArrayList<Employee> employees) {
for (var emp : employees) {
if (emp.getIdEmp().compareTo(idremove) == 0) {
employees.remove(emp);
return true;
}
}
return false;
}
/**
* tìm giám đốc theo nhiệm kỳ
* @param startYear
* @param endYear
* @param employees
* @return
*/
private static ArrayList<Employee> findManagerByTerm(int startYear, int endYear, ArrayList<Employee> employees) {
ArrayList<Employee> res = new ArrayList<>();
Calendar calendar = Calendar.getInstance();//trả về đối tượng Calendar cho thời
// gian hiện thời(tóm lại dòng này là khai báo mặc định để dử dụng lớp Calender)
for (var emp : employees) {
if (emp instanceof Manager) {
var mng = (Manager) emp;
calendar.setTime(mng.getStartTerm());
var start = calendar.get(Calendar.YEAR);
calendar.setTime(mng.getEndTerm());
var end = calendar.get(Calendar.YEAR);
//nếu nhiệm kỳ cần tìm
if (start <= startYear && end >= endYear) {
res.add(emp);
}
}
}
return res;
}
/**
* tìm kiếm nhân viên theo mức lương
* @param amount
* @param employees
* @return
*/
private static ArrayList<Employee> searchByWages(float amount, ArrayList<Employee> employees) {
ArrayList<Employee> res = new ArrayList<>();
for (var emp : employees) {
if (emp.getBasicWages() >= amount) {
res.add(emp);
}
}
return res;
}
/**
* tìm nhân viên theo tên (không chứa họ và đệm)
* @param name
* @param employees
* @return
*/
private static ArrayList<Employee> searchByName(String name, ArrayList<Employee> employees) {
ArrayList<Employee> res = new ArrayList<>();
for (var emp : employees) {
if (emp.getFullNameStr().getLastName().compareToIgnoreCase(name) == 0) {
res.add(emp);
}
}
return res;
}
/**
* hiển thị nhân viên theo bảng
* @param employees
*/
private static void showEmp(ArrayList<Employee> employees) {
System.out.printf("%-20s %-26s %-15s %-14s %-24s %-18s %-17s %-13s %-14s %-16s %-16s\n",
"Số thẻ căn cước", "Họ và tên", "Địa chỉ", "Ngày sinh", "Email",
"Số điện thoại", "Mã nhân viên", "Vị trí", "Mức lương", "Kinh nghiệm", "Số ngày làm việc");
for (var emp : employees) {
showInfoEmp(emp);
}
}
/**
* hiển thị thông tin của từng nhân viên
* @param emp
*/
private static void showInfoEmp(Employee emp) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
System.out.printf("%-20s %-26s %-15s %-14s %-24s %-18s %-17s %-13s %-14.1f %-16.1f %-16d\n",
emp.getIdCard(), emp.getFullName(), emp.getAddress(), dateFormat.format(emp.getDayOfBirth()),
emp.getEmail(), emp.getPhoneNumber(), emp.getIdEmp(), emp.getPosition(), emp.getBasicWages(),
emp.getExperience(), emp.getDayInTheMonth());
}
/**
* thêm mới một giám đốc
* @param input
* @return
*/
private static Manager createMng(Scanner input) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
Employee employee = createEmp(input);
System.out.println("Ngày bắt đầu nhiệm kỳ: ");
Date start = null;
try {
start = dateFormat.parse(input.nextLine());
} catch (ParseException e) {
e.printStackTrace();
start = new Date();
}
System.out.println("Ngày kết thúc nhiệm kỳ: ");
Date end = null;
try {
end = dateFormat.parse(input.nextLine());
} catch (ParseException e) {
e.printStackTrace();
end = new Date();
}
Manager manager = new Manager(employee, start, end);
return manager;
}
/**
* thêm mới một nhân viên
* @param input
* @return
*/
private static Employee createEmp(Scanner input) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
System.out.println("-----Nhập thông tin nhân viên mới-----");
System.out.println("Số thẻ căn cước: ");
var idCard = input.nextLine();
System.out.println("Họ và tên: ");
var name = input.nextLine();
System.out.println("Địa chỉ: ");
var address = input.nextLine();
System.out.println("Ngày sinh: ");
Date dob = null;
try {
dob = dateFormat.parse(input.nextLine());
} catch (ParseException e) {
e.printStackTrace();
dob = new Date(); //nếu nhập sai thì mặc định là ngày hôm nay
}
System.out.println("Email: ");
var mail = input.nextLine();
System.out.println("Số điện thoại: ");
var phone = input.nextLine();
System.out.println("Vị trí: ");
var posi = input.nextLine();
System.out.println("Mức lương: ");
var wage = Float.parseFloat(input.nextLine());
System.out.println("Kinh nghiệm: ");
var exp = Float.parseFloat(input.nextLine());
System.out.println("Số ngày làm việc trong tháng: ");
var dim = Integer.parseInt(input.nextLine());
//vì không cần nhập bonus và receive nên để là 0
Employee employee = new Employee(idCard, name, address, dob, mail, phone,
null, posi, wage, exp, dim, 0, 0);
return employee;
}
/**
* hiển thị thông báo khi kết thúc một hành động
* @param str thông báo được hiển thị
*/
private static void showNotify(String str) {
System.out.println(">>>>> " + str + " <<<<<");
}
}
|
package com.hason.dtp.test.account.web;
import com.hason.dtp.account.entity.User;
import com.hason.dtp.core.utils.result.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import java.util.concurrent.*;
/**
* 模拟并发注册
*
* @author Huanghs
* @since 2.0
* @date 2017/11/15
*/
public class MockConcurrent {
private static BlockingQueue<Runnable> queue = new LinkedBlockingDeque<>();
private static ExecutorService pool =
new ThreadPoolExecutor(5, 5, 1, TimeUnit.MILLISECONDS, queue);
public static void main(String[] args) {
int threads = 3;
while (threads-- > 0) {
pool.execute(MockConcurrent::task);
}
}
private static final String url = "http://localhost:8001/register";
/** 注册用户名的后缀 */
private static volatile int num = 5153;
/** 时间间隔 */
private static final long INTERVAL = 10;
public static void task() {
RestTemplate template = new RestTemplateBuilder().build();
while (true) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
params.add("username", "hason" + num++);
params.add("password", "123");
HttpEntity<MultiValueMap<String, String>> entity = new HttpEntity<>(params, headers);
ParameterizedTypeReference<Result<User>> reference = new ParameterizedTypeReference<Result<User>>() {};
ResponseEntity<Result<User>> response = template.exchange(url, HttpMethod.POST, entity, reference);
if (response.getStatusCode() == HttpStatus.OK) {
Result<User> result = response.getBody();
if (result.success()) {
System.out.println("成功注册：" + result.getData().getUsername());
} else {
System.out.println("注册失败：" + result.getError().getMessage());
}
} else {
System.out.println("网络错误： " + response.getStatusCodeValue() + " " + response.getBody());
}
sleep(INTERVAL);
}
}
private static void sleep(long timeout) {
try {
TimeUnit.MILLISECONDS.sleep(timeout);
} catch (InterruptedException e) {
}
}
}
|
package com.ssgl.mapper;
import com.ssgl.bean.Floor;
import com.ssgl.bean.FloorExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface FloorMapper {
int countByExample(FloorExample example);
int deleteByExample(FloorExample example);
int deleteByPrimaryKey(Integer id);
int insert(Floor record);
int insertSelective(Floor record);
List<Floor> selectByExample(FloorExample example);
Floor selectByPrimaryKey(Integer id);
int updateByExampleSelective(@Param("record") Floor record, @Param("example") FloorExample example);
int updateByExample(@Param("record") Floor record, @Param("example") FloorExample example);
int updateByPrimaryKeySelective(Floor record);
int updateByPrimaryKey(Floor record);
} |
package com.example.rockroku.somkiatbankmobilebanking;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import com.example.rockroku.somkiatbankmobilebanking.common.BaseActivity;
public class ConfirmActivity extends BaseActivity implements View.OnClickListener {
private Button mBtConfirm;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_confirm);
bindView();
setViewListener();
}
private void bindView() {
mBtConfirm = (Button) findViewById(R.id.btn_confirm);
}
private void setViewListener() {
mBtConfirm.setOnClickListener(this);
}
@Override
public void onClick(View view) {
if (view == mBtConfirm) {
openActivity(TransferResultActivity.class);
}
}
}
|
package com.tkb.elearning.model;
import java.sql.Timestamp;
public class MeetingMinutes {
private int id; //id
private int class_no; //屆別(數字)
private String meeting_name; //會議名稱
private String meeting_date; //開會日期
private String content; //內容
private String status; //狀態
private Timestamp create_date; //建立日期
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getClass_no() {
return class_no;
}
public void setClass_no(int class_no) {
this.class_no = class_no;
}
public String getMeeting_name() {
return meeting_name;
}
public void setMeeting_name(String meeting_name) {
this.meeting_name = meeting_name;
}
public String getMeeting_date() {
return meeting_date;
}
public void setMeeting_date(String meeting_date) {
this.meeting_date = meeting_date;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Timestamp getCreate_date() {
return create_date;
}
public void setCreate_date(Timestamp create_date) {
this.create_date = create_date;
}
}
|
package jp.co.logacy.validator.user;
import jp.co.logacy.dto.user.UserDto;
import jp.co.logacy.exception.SmyException;
/**
* ユーザ登録バリデータチェッククラス
* @author User
*
*/
public class CheckUserRegistParameter {
/**
* 必須パラメータが未入力かどうか
* @param {@link UserDto}
* @return true:未入力<br>
* false:入力されている
*/
public static boolean isEmptyRequiredParameter(final UserDto userDto) {
if (userDto == null) {
throw new SmyException("userDtoがnullです");
}
if (userDto.name == null || userDto.name.equals("")) {
return true;
}
if (userDto.password == null || userDto.password.equals("")) {
return true;
}
if (userDto.sex == null || userDto.sex.equals("")) {
return true;
}
return false;
}
}
|
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.insat.gl5.crm_pfa.web.viewModel;
import com.insat.gl5.crm_pfa.model.EmailAdress;
/**
*
* @author
* Mu7ammed
* 3li
* --
* mohamed.ali.affes@gmail.com
* --
*/
public class EmailViewModel {
private int index;
private EmailAdress email;
public EmailViewModel() {
}
public EmailViewModel(int index, EmailAdress email) {
this.index = index;
this.email = email;
}
/**
* @return the index
*/
public int getIndex() {
return index;
}
/**
* @param index the index to set
*/
public void setIndex(int index) {
this.index = index;
}
/**
* @return the email
*/
public EmailAdress getEmail() {
return email;
}
/**
* @param email the email to set
*/
public void setEmail(EmailAdress email) {
this.email = email;
}
}
|
package com.fixit.rest.queries;
import java.util.ArrayList;
import java.util.List;
/**
* Created by konstantin on 5/17/2017.
*/
public class DataQueryCriteria {
private List<DataApiQuery> queries;
private DataQueryCriteria() {
queries = new ArrayList<>();
}
public static DataQueryCriteria create() {
return new DataQueryCriteria();
}
public static DataQueryCriteria create(DataApiQuery query) {
return new DataQueryCriteria().add(query);
}
public DataQueryCriteria add(DataApiQuery... queries) {
for(DataApiQuery query : queries) {
this.queries.add(query);
}
return this;
}
public List<DataApiQuery> queries() {
return queries;
}
public DataApiQuery[] build() {
return queries.toArray(new DataApiQuery[queries.size()]);
}
public void reset() {
queries.clear();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for(DataApiQuery query : queries) {
sb.append(query.toString()).append(" AND ");
}
return sb.toString();
}
}
|
package Utili.Package;
import android.util.Log;
public class LogUtil {
public static void i(String tag, Object msg) {
//����ϲ���ӡ��־
if (false) {
return;
}
Log.i(tag, String.valueOf(msg));
}
}
|
package com.aviary.wp;
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.widget.ImageView;
import android.widget.LinearLayout;
public class WorkspaceIndicator extends LinearLayout {
int mResId;
int mSelected;
public WorkspaceIndicator( Context context, AttributeSet attrs ) {
super( context, attrs );
init( context, attrs, 0 );
}
private void init( Context context, AttributeSet attrs, int defStyle ) {
TypedArray a = context.obtainStyledAttributes( attrs, R.styleable.WorkspaceIndicator, defStyle, 0 );
setOrientation( LinearLayout.HORIZONTAL );
mResId = a.getResourceId( R.styleable.WorkspaceIndicator_indicatorId, 0 );
if ( mResId != 0 ) {
context.getResources().getDrawable( mResId );
}
a.recycle();
}
void resetView( int count ) {
removeAllViews();
if ( mResId != 0 && count > 0 ) {
for ( int i = 0; i < count; i++ ) {
ImageView v = new ImageView( getContext() );
v.setImageResource( mResId );
v.setSelected( false );
v.setPadding( 1, 0, 1, 0 );
addView( v );
}
}
}
public void setLevel( int mCurrentScreen, int mItemCount ) {
if ( getChildCount() != mItemCount ) {
resetView( mItemCount );
mSelected = 0;
}
if ( mCurrentScreen >= 0 && mCurrentScreen < getChildCount() ){
getChildAt( mSelected ).setSelected( false );
getChildAt( mCurrentScreen ).setSelected( true );
mSelected = mCurrentScreen;
}
}
}
|
package crundle.qralarmclock;
import android.Manifest;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Color;
import android.media.RingtoneManager;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class AlarmSettingsActivity extends AppCompatActivity {
public static ArrayList<Alarm> alarms = new ArrayList<Alarm>();
private Alarm currentAlarm = null;
private Integer currentAlarmIndex = null;
private Spinner ringtonesSpinner;
private static String id, uri, uri_used;
/*
* Sets the screen to the alarm settings page. It will set the information to display the proper
* information from the alarm object and be edit a selected alarm.
*/
@Override
@TargetApi(23)
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_alarm_settings);
Intent intent = getIntent();
if (intent.hasExtra("alarm")) {
String alarmTime = intent.getStringExtra("alarm");
//finding the alarm being edited
for (int i = 0; i < alarms.size(); i++) {
if (alarms.get(i).getAlarmTime().equals(alarmTime)) {
currentAlarm = alarms.get(i);
currentAlarmIndex = i;
}
}
TimePicker tp = (TimePicker) findViewById(R.id.timePicker1);
LinearLayout daysView = (LinearLayout) findViewById(R.id.linearLayout2);
//setting timepicker attributes of the alarm settings display
if (currentAlarm.getAM())
tp.setHour(currentAlarm.getHour());
else
tp.setHour(currentAlarm.getHour() + 12);
tp.setMinute(currentAlarm.getMin());
//setting days active attributes of the alarm settings display
boolean[] days = currentAlarm.daysActive;
for (int i = 0; i < daysView.getChildCount(); i++) {
View v = daysView.getChildAt(i);
if (days[i]) {
((TextView) v).setTextColor(Color.parseColor("#FF0000"));
} else {
((TextView) v).setTextColor(Color.parseColor("#800000"));
}
}
} else {
//in the case of a new alarm being created
currentAlarm = null;
currentAlarmIndex = null;
}
ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.READ_EXTERNAL_STORAGE}, 1);
RingtoneManager ringtoneMgr = new RingtoneManager(this);
ringtoneMgr.setType(RingtoneManager.TYPE_ALARM);
Cursor alarmsCursor = ringtoneMgr.getCursor();
String[] from = {alarmsCursor.getColumnName(RingtoneManager.TITLE_COLUMN_INDEX)};
int[] to = {android.R.id.text1};
SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_spinner_item, alarmsCursor, from, to);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
ringtonesSpinner = (Spinner)findViewById(R.id.spinner);
ringtonesSpinner.setAdapter(adapter);
id = alarmsCursor.getString(RingtoneManager.ID_COLUMN_INDEX);
uri = alarmsCursor.getString(RingtoneManager.URI_COLUMN_INDEX);
uri_used = alarmsCursor.getString(RingtoneManager.URI_COLUMN_INDEX) + "/" + alarmsCursor.getString(RingtoneManager.ID_COLUMN_INDEX);
}
/* Activate/Deactivate RepeatedDays
* JUST CHANGES COLOR at the moment
* Should eventually set relevant alarm's settings
*/
public void toggleDay(View view) {
TextView tv = (TextView) view;
// Get day number from TextView tag, convert to int
Log.d((String) tv.getTag(), "oi 12345");
int dayNum = Integer.parseInt((String) tv.getTag()); //nasty
if (tv.getCurrentTextColor() == Color.parseColor("#800000")) {
tv.setTextColor(Color.parseColor("#FF0000"));
} else {
tv.setTextColor(Color.parseColor("#800000"));
}
}
/* Cancel changes
* - Go back to MainAlarmsActivity
*/
public void cancel(View view) {
Intent intent;
intent = new Intent(this, MainAlarmsActivity.class);
startActivity(intent);
}
/*
* Save changes
* - Update alarm's settings, save file, go back to MainAlarmsActivity
*/
public void save(View view){
Alarm a = new Alarm();
TimePicker tp = (TimePicker) findViewById(R.id.timePicker1);
LinearLayout days = (LinearLayout) findViewById(R.id.linearLayout2);
// getCurrentMinute will return only 1 digit when <10,
// so time ends up looking like "5:0"
// Add in a 0 before single digit minutes
String min = Integer.toString(tp.getCurrentMinute());
if (min.length() == 1) {
min = "0" + min;
}
int hour = tp.getCurrentHour();
// get the days that are active
for (int i = 0; i < days.getChildCount(); i++) {
View v = days.getChildAt(i);
if (v instanceof TextView) {
int tag = Integer.parseInt((String) v.getTag());
if (((TextView) v).getCurrentTextColor() == Color.parseColor("#FF0000")) {
a.setDaysActive(tag);
}
}
}
//setting various alarm settings
if (hour > 12) {
a.setHour(hour - 12);
a.setAM(false);
} else {
a.setHour(hour);
a.setAM(true);
}
a.setAlarm_id(uri_used);
a.setMin(tp.getCurrentMinute());
a.setAlarmTime(Integer.toString(tp.getCurrentHour()) + ":" + min);
//Message of successful alarm save
Toast.makeText(this, "Alarm Saved", Toast.LENGTH_LONG).show();
//checks if an alarm with the same time exists and deletes it
for (int i = 0; i < alarms.size(); i++) {
if (alarms.get(i).getAlarmTime().equals(tp.getCurrentHour() + ":" + min)) {
deleteAlarm(this, alarms.get(i));
break;
}
}
//checks if the alarm was toggled off before editing, if so it remains off
a.setActive(true);
if (!(currentAlarm == null)) {
a.setActive(currentAlarm.isActive());
deleteAlarm(this, currentAlarm);
}
alarms.add(a);
//creates the Android alarm if it is active
if(a.isActive()) {
AlarmReceiver.setAndroidAlarm(this, a);
}
//saving to file
saveFile(this);
//return to Main Alarms Activity
Intent intent;
intent = new Intent(this, MainAlarmsActivity.class);
startActivity(intent);
}
/*
* Sorts and saves the alarms for use between sessions
*/
public static void saveFile(Context context) {
Collections.sort(alarms);
FileOutputStream fos = null;
try {
fos = context.openFileOutput("AlarmList.txt", Context.MODE_PRIVATE);
ObjectOutputStream os = new ObjectOutputStream(fos);
for (Alarm a : alarms) {
os.writeObject(a);
}
os.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* Returns an ArrayList of the alarms from the saved AlarmList file
*/
public static ArrayList<Alarm> getSavedAlarms(Context context) throws IOException, ClassNotFoundException {
ArrayList<Alarm> tempAlarms = new ArrayList<Alarm>();
File directory = context.getFilesDir();
File file = new File(directory, "AlarmList.txt");
Boolean keepGoing = true;
FileInputStream fi = null;
ObjectInputStream oi = null;
try {
fi = new FileInputStream(file);
oi = new ObjectInputStream(fi);
while (keepGoing) {
tempAlarms.add((Alarm) oi.readObject());
}
} catch (EOFException e) {
keepGoing = false;
}
if (fi != null)
fi.close();
if (oi != null)
oi.close();
return tempAlarms;
}
/*
* Deletes an alarm from the internal list, the saved file, and the Android alarms
*/
public static void deleteAlarm(Context context, Alarm a) {
alarms.remove(a);
AlarmReceiver.deleteAndroidAlarm(context, a);
saveFile(context);
}
}
|
package com.yixin.kepler.core.service.impl.cmbc;
import com.yixin.common.utils.InvokeResult;
import com.yixin.dsc.dto.DscFlowResultForAlixDto;
import com.yixin.dsc.enumpackage.DscAlixLinkEnum;
import com.yixin.kepler.common.enums.BankPhaseEnum;
import com.yixin.kepler.core.constant.CommonConstant;
import com.yixin.kepler.core.domain.cmbc.SelectResultStrategy;
import com.yixin.kepler.core.service.BankResultService;
import com.yixin.kepler.dto.BaseMsgDTO;
import com.yixin.kepler.enity.AssetBankTran;
import com.yixin.kepler.enity.AssetResultTask;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author sukang on 2018/8/31.
*/
@Service("CMBCResultService")
public class CMBCResultServiceImpl implements BankResultService{
private final Logger logger = LoggerFactory.getLogger(getClass());
/**
* 民生银行查询交易结果策略
*/
private SelectResultStrategy selectResultStrategy;
@Autowired
public CMBCResultServiceImpl(SelectResultStrategy selectResultStrategy) {
this.selectResultStrategy = selectResultStrategy;
}
@Override
public BaseMsgDTO selectResult(AssetResultTask assetResultTask) {
InvokeResult<BaseMsgDTO> result = selectResultStrategy.doIt(assetResultTask);
//获取该订单的银行交易记录
AssetBankTran bankTran = AssetBankTran.get(AssetBankTran.class,
assetResultTask.getTranId());
logger.info("订单号{},阶段为{},获取到的任务执行结果为{}",assetResultTask.getApplyNo()
,bankTran.getPhase(), JSONObject.fromObject(result).toString());
//民生银行信审结果发送alix结果通知
BaseMsgDTO baseMsgDTO = (BaseMsgDTO) result.getData();
DscFlowResultForAlixDto dscFlowResultForAlixDto = null;
if (baseMsgDTO.successed()){
dscFlowResultForAlixDto = createForAliDto(bankTran,true,"success");
}else if (CommonConstant.FAILURE.equals(baseMsgDTO.getCode())){
dscFlowResultForAlixDto = createForAliDto(bankTran,false,baseMsgDTO.getMessage());
}
if (dscFlowResultForAlixDto != null){
publishEvent(dscFlowResultForAlixDto);
}
return baseMsgDTO;
}
private DscFlowResultForAlixDto createForAliDto(AssetBankTran bankTran,
Boolean isSuccess, String msg) {
if (BankPhaseEnum.PAYMENT.getPhase().equals(bankTran.getPhase())) {
return null;
}
return DscFlowResultForAlixDto.createForAliDto(bankTran.getApplyNo(),
isSuccess, msg, DscAlixLinkEnum.CREDITFRONT);
}
}
|
package com.scholanova.ecommerce.cart.controller;
import com.scholanova.ecommerce.cart.entity.Cart;
import com.scholanova.ecommerce.cart.exception.CartException;
import com.scholanova.ecommerce.cart.repository.CartRepository;
import com.scholanova.ecommerce.cart.service.CartService;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.config.EnableSpringDataWebSupport;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.stream.Collectors;
@RestController
@EnableSpringDataWebSupport
@RequestMapping("/carts")
public class CartController {
private CartRepository cartRepository;
private CartService cartService;
public CartController(CartRepository cartRepository, CartService cartService) {
this.cartRepository = cartRepository;
this.cartService = cartService;
}
@GetMapping
public List<Cart> getAllCarts(Pageable pageable) {
return cartRepository.findAll(pageable).get().collect(Collectors.toList());
}
@GetMapping("/{id}")
public Cart getCartById(@PathVariable("id") Cart cart) { return cart;}
@PostMapping
public Cart createCart() { return cartRepository.save(new Cart()); }
@PostMapping("/{id}/items")
public Cart addProductToCart(@PathVariable("id)") Cart cart, @RequestBody ItemWithQuantity payload) throws CartException {
return cartService.addProductToCart(cart, payload.productId, payload.quantity);
}
@PutMapping("/{cartid}/items/{productId}/quantity")
public Cart changeProductQuantity(@PathVariable("cartId") Cart cart, @PathVariable("productId") Long productId, @RequestBody int quantity) throws CartException {
return cartService.changeProductQuantity(cart, productId, quantity);
}
public class ItemWithQuantity {
Long productId;
int quantity;
}
}
|
package exer;
import java.util.Scanner;
/**
* @author menglanyingfei
* @date 2017-7-12
*/
public class Main06_SumOfPrime {
/**
* @param args
* 输入格式: 两个整数，第一个表示n，第二个表示m。 输出格式：
* 一个整数，表示第n个素数到第m个素数之间所有的素数的和，包括第n个素数和第m个素数。
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
sc.close();
int count = 0; // 计数
int sum = 0;
if (0 < n && n <= m && m <= 200) {
for (int i = 2; i <= 2000; i++) {
boolean flag = true;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag) {
count++;
if (count >= n)
sum = sum + i;
if (count == m)
break;
}
}
System.out.println(sum);
}
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package BEncoding.BElement;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
*
* @author Robert
*/
public class BDictionary implements BElement
{
public TreeMap<BString, BElement> Values = new TreeMap<BString, BElement>();
public BDictionary() {}
public BDictionary(Map<String, BElement> vals)
{
for (Map.Entry<String, BElement> entry : vals.entrySet())
{
Values.put(new BString(entry.getKey()), entry.getValue()) ;
}
}
/**
* Generates the bencoded equivalent of the dictionary.
* @return Bencoded equivalent of the dictionary.
*/
@Override
public String ToBencodedString()
{
return this.ToBencodedString(new StringBuilder()).toString();
}
/**
* Generates the bencoded equivalent of the dictionary.
* @param u StringBuilder to append to.
* @return Bencoded equivalent of the dictionary.
*/
@Override
public StringBuilder ToBencodedString(StringBuilder u)
{
if (u == null) u = new StringBuilder('d');
else u.append('d');
for (Map.Entry<BString, BElement> entry : Values.entrySet())
{
entry.getKey().ToBencodedString(u);
entry.getValue().ToBencodedString(u);
}
return u.append('e');
}
/**
* Adds the specified key-value pair to the dictionary.
* @param key Specified BString key.
* @param value specified BElement value.
*/
public void Add(BString key, BElement value)
{
Values.put(key, value);
}
/**
* Adds the specified key-value pair to the dictionary.
* @param key Specified key.
* @param value specified BElement value.
*/
public void Add(String key, BElement value)
{
Values.put(new BString(key), value);
}
/**
* Adds the specified key-value pair to the dictionary.
* @param key Specified key.
* @param value Specified String value
*/
public void Add(String key, String value)
{
Values.put(new BString(key), new BString(value));
}
/**
* Adds the specified key-value pair to the dictionary.
* @param key Specified key.
* @param value Specified Integer value
*/
public void Add(String key, Integer value)
{
Values.put(new BString(key), new BInteger(value));
}
/**
* Converts Values to {@literal Map <String, BElement>}
* @return new {@literal Map<String, BElement>}
*/
public Map<String, BElement> getMap()
{
Map<String, BElement> ret = new TreeMap<>();
for (Map.Entry<BString, BElement> entry : Values.entrySet())
{
ret.put(entry.getKey().toString(), entry.getValue()) ;
}
return ret;
}
@Override
public String getString()
{
throw new RuntimeException("Type is BDictionary, shouldnt it be BString??");
}
@Override
public List<BElement> getList()
{
throw new RuntimeException("Type is BInteger, shouldnt it be BList??");
}
@Override
public int getInt()
{
throw new RuntimeException("Type is BDictionary, shouldnt it be BInteger??");
}
@Override
public long getLong()
{
throw new RuntimeException("Type is BDictionary, shouldnt it be BInteger??");
}
@Override
public String toString()
{
String s = "";
for (Map.Entry<BString, BElement> entry : Values.entrySet())
{
s+= "key:" + entry.getKey().toString() + " ";
s+= "value:" + entry.getValue().toString() + " ";
}
return s;
}
}
|
package VEW.XMLCompiler.ASTNodes;
import VEW.Planktonica2.Model.Catagory;
public class RuleSequenceNode extends ASTree {
private String ruleName;
private RuleNode rule;
private RuleSequenceNode seq;
public RuleSequenceNode(RuleNode rNode) {
this.rule = rNode;
this.seq = null;
this.ruleName = null;
}
public RuleSequenceNode(String ruleName, RuleNode rNode) {
this.ruleName = ruleName;
this.rule = rNode;
}
public RuleSequenceNode(RuleNode rNode, RuleSequenceNode seqNode) {
this.rule = rNode;
this.seq = seqNode;
this.ruleName = null;
}
public RuleSequenceNode(String ruleName, RuleNode rNode, RuleSequenceNode seqNode) {
this.ruleName = ruleName;
this.rule = rNode;
this.seq = seqNode;
}
public void setRuleSequence(RuleSequenceNode seq) {
this.seq = seq;
}
@Override
public void check(Catagory enclosingCategory, ConstructedASTree enclosingTree) {
rule.check(enclosingCategory, enclosingTree);
if (seq != null) {
seq.check(enclosingCategory, enclosingTree);
}
}
@Override
public String generateXML() {
String name = "LOLNAME";
if (ruleName != null) {
name = ruleName;
}
if (seq != null) {
return name + ":" + rule.generateXML()
+ ";" + seq.generateXML();
} else {
return name + ":" + rule.generateXML();
}
}
public String generateLatex() {
if (seq != null) {
if (rule != null)
return "\\\\ \\\\ \\;" + rule.generateLatex()
+ seq.generateLatex();
else
return "\\\\ \\\\ \\;???"
+ seq.generateLatex();
} else {
if (rule != null)
return "\\\\ \\\\ \\;" + rule.generateLatex();
else
return "\\\\ \\\\ \\;???";
}
}
}
|
package com.store.controller;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.store.service.EquipmentService;
import com.store.service.EquipmentServiceImpl;
import com.store.pojo.Equipment;
/**
* Servlet implementation class UpdateEquipmentServlet
*/
@WebServlet("/UpdateEquipmentServlet")
public class EquipmentUpdateServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setCharacterEncoding("utf-8");
response.setContentType("text/html; charset=utf-8");
int id = Integer.parseInt(request.getParameter("id"));
String equipment_id = request.getParameter("equipment_id");
String equipment_name = request.getParameter("equipment_name");
String equipment_type = request.getParameter("equipment_type");
String createtime = request.getParameter("createtime");
String responsible_person = request.getParameter("responsible_person");
String remark = request.getParameter("remark");
Equipment equipment = new Equipment();
equipment.setId(id);
equipment.setEquipment_id(equipment_id);
equipment.setEquipment_name(equipment_name);
equipment.setEquipment_type(equipment_type);
equipment.setCreatetime(createtime);
equipment.setResponsible_person(responsible_person);
equipment.setRemark(remark);
System.out.println(equipment);
EquipmentService e = new EquipmentServiceImpl();
e.updateEquipment(equipment);
request.getRequestDispatcher("EquipmentServlet").forward(request, response);
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
|
package de.jmda.fx.sandbox.graph.uml;
import javafx.scene.Node;
public abstract class Head implements de.jmda.fx.sandbox.graph.Head
{
protected PointA pointA;
protected PointB pointB;
protected PointC pointC;
public Head(int size)
{
// if (not(isOdd(size))) throw new IllegalArgumentException("value for size must be odd");
pointA = new PointA(-size/2,size/2);
pointB = new PointB( size/2,size/2);
pointC = new PointC(); // defaults to Point2d(0, 0)
}
@Override public PointC getFront() { return pointC; }
public abstract Node asNode();
public PointA getPointA() { return pointA; }
public PointB getPointB() { return pointB; }
public PointC getPointC() { return pointC; }
} |
/**
* @Copyright CopperMobile 2014
* */
package com.atn.app.database.handler;
public class UserTable
{
public static final String USER_TABLE = "USER_TABLE";
public static final String COL_USER_CREATED = "created";
public static final String COL_USER_DOB = "date_of_birth";
public static final String COL_USER_EMAIL = "email";
public static final String COL_USER_FB_ACCESS_TOKEN = "fb_access_token";
public static final String COL_USER_FB_LINK = "fb_link";
public static final String COL_USER_FB_UID = "fb_uid";
public static final String COL_USER_FIRST_NAME = "first_name";
public static final String COL_USER_GENDER = "gender";
public static final String COL_USER_ID = "user_id";
public static final String COL_USER_MANNUAL_LOGIN = "isManualLogin";
public static final String COL_USER_LAST_NAME = "last_name";
public static final String COL_USER_LOCATION = "location";
public static final String COL_USER_MODIFIED = "modified";
public static final String COL_USER_POINTS = "points";
public static final String COL_USER_NAME = "user_name";
public static final String create_user_table = "CREATE TABLE " + USER_TABLE + " ( "
+ COL_USER_CREATED + " TEXT, "
+ COL_USER_DOB + " TEXT, "
+ COL_USER_EMAIL + " TEXT, "
+ COL_USER_FB_ACCESS_TOKEN + " TEXT, "
+ COL_USER_FB_LINK + " TEXT, "
+ COL_USER_FB_UID + " TEXT, "
+ COL_USER_FIRST_NAME + " TEXT, "
+ COL_USER_GENDER + " INTEGER DEFAULT 0, "
+ COL_USER_ID + " TEXT PRIMARY KEY, "
+ COL_USER_MANNUAL_LOGIN + " BOOLEAN, "
+ COL_USER_LAST_NAME + " TEXT, "
+ COL_USER_LOCATION + " TEXT, "
+ COL_USER_MODIFIED + " TEXT, "
+ COL_USER_POINTS + " TEXT, "
+ COL_USER_NAME + " TEXT )";
}
|
/*
* [y] hybris Platform
*
* Copyright (c) 2018 SAP SE or an SAP affiliate company. All rights reserved.
*
* This software is the confidential and proprietary information of SAP
* ("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 SAP.
*/
package de.hybris.platform.cmsfacades.navigations.validator;
import de.hybris.platform.cmsfacades.constants.CmsfacadesConstants;
import de.hybris.platform.cmsfacades.data.NavigationEntryData;
import de.hybris.platform.cmsfacades.data.NavigationNodeData;
import de.hybris.platform.cmsfacades.navigations.service.NavigationEntryConverterRegistry;
import de.hybris.platform.cmsfacades.navigations.service.NavigationEntryItemModelConverter;
import de.hybris.platform.core.model.ItemModel;
import de.hybris.platform.servicelayer.dto.converter.ConversionException;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.IntStream;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
/**
* Validates all the entries of a given {@link NavigationNodeData}.
*/
public class NavigationNodeEntriesValidator implements Validator
{
private static final Logger LOG = LoggerFactory.getLogger(NavigationNodeEntriesValidator.class);
private static final String ITEM_SUPER_TYPE = "itemSuperType";
private static final String ITEM_ID = "itemId";
private static final String ENTRIES = "entries";
private NavigationEntryConverterRegistry navigationEntryConverterRegistry;
private Predicate<ItemModel> validEntryItemModelPredicate;
@Override
public boolean supports(final Class<?> clazz)
{
return NavigationNodeData.class.isAssignableFrom(clazz);
}
@Override
public void validate(final Object obj, final Errors errors)
{
final NavigationNodeData target = (NavigationNodeData) obj;
if (!CollectionUtils.isEmpty(target.getEntries()))
{
IntStream.range(0, target.getEntries().size()).forEach(idx -> {
final NavigationEntryData entryData = target.getEntries().get(idx);
if (StringUtils.isEmpty(entryData.getItemId()))
{
errors.rejectValue(ENTRIES, CmsfacadesConstants.FIELD_REQUIRED_NAVIGATION_NODE_ENTRY, new Object[]
{ ITEM_ID, idx }, null);
}
if (StringUtils.isEmpty(entryData.getItemSuperType()))
{
errors.rejectValue(ENTRIES, CmsfacadesConstants.FIELD_REQUIRED_NAVIGATION_NODE_ENTRY, new Object[]
{ ITEM_SUPER_TYPE, idx }, null);
}
if (!StringUtils.isEmpty(entryData.getItemSuperType()) && !StringUtils.isEmpty(entryData.getItemId()))
{
validateEntryItem(errors, idx, entryData);
}
});
}
}
/**
* Validates if it is a valid item
*
* @param errors
* the errors object created for this validation
* @param idx
* the index of the current entry
* @param entryData
* the entry being validated
*/
protected void validateEntryItem(final Errors errors, final int idx, final NavigationEntryData entryData)
{
final Optional<NavigationEntryItemModelConverter> optionalConverter = getNavigationEntryConverterRegistry()
.getNavigationEntryItemModelConverter(entryData.getItemSuperType());
if (!optionalConverter.isPresent())
{
errors.rejectValue(ENTRIES, CmsfacadesConstants.FIELD_NAVIGATION_NODE_ENTRY_CONVERTER_NOT_FOUND, new Object[]
{ ITEM_SUPER_TYPE, idx }, null);
}
else
{
try
{
if (!getValidEntryItemModelPredicate().test(optionalConverter.get().getConverter().apply(entryData)))
{
errors.rejectValue(ENTRIES, CmsfacadesConstants.FIELD_CIRCULAR_DEPENDENCY_ON_NAVIGATION_NODE_ENTRY, new Object[]
{ ITEM_ID, idx }, null);
}
}
catch (final ConversionException e)
{
LOG.info(e.getMessage(), e);
errors.rejectValue(ENTRIES, CmsfacadesConstants.FIELD_NAVIGATION_NODE_ENTRY_CONVERSION_ERROR, new Object[]
{ ITEM_ID, idx }, null);
}
}
}
protected NavigationEntryConverterRegistry getNavigationEntryConverterRegistry()
{
return navigationEntryConverterRegistry;
}
@Required
public void setNavigationEntryConverterRegistry(final NavigationEntryConverterRegistry navigationEntryConverterRegistry)
{
this.navigationEntryConverterRegistry = navigationEntryConverterRegistry;
}
protected Predicate<ItemModel> getValidEntryItemModelPredicate()
{
return validEntryItemModelPredicate;
}
@Required
public void setValidEntryItemModelPredicate(final Predicate<ItemModel> validEntryItemModelPredicate)
{
this.validEntryItemModelPredicate = validEntryItemModelPredicate;
}
}
|
package com.te.springmvc.dao;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.PersistenceUnit;
import javax.persistence.Query;
import org.springframework.stereotype.Repository;
import com.te.springmvc.beans.EmployeeBean;
import com.te.springmvc.customexceptions.EmployeeException;
@Repository
public class EmployeeDaoImpl implements EmployeeDao {
// @PersistenceUnit
// private EntityManagerFactory factory;
@Override
public EmployeeBean authenticate(int id, String pwd) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
try {
EmployeeBean bean = manager.find(EmployeeBean.class, id);
if (bean != null) {
if (bean.getPassword().equals(pwd)) {
System.out.println("Login Successful");
return bean;
} else {
System.out.println("Invalid Password");
return null;
}
} else {
System.out.println("Invalid Login Credentials");
throw new EmployeeException("Id Not Present");
}
} catch (Exception e) {
e.printStackTrace();
throw new EmployeeException("Id Not Present");
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
}
@Override
public EmployeeBean getEmployee(int id) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
EmployeeBean bean = null;
try {
bean = manager.find(EmployeeBean.class, id);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
return bean;
}
@Override
public boolean deleteEmployee(int id) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
EntityTransaction transaction = manager.getTransaction();
try {
EmployeeBean bean = manager.find(EmployeeBean.class, id);
transaction.begin();
boolean b = (bean != null) ? true : false;
if (b) {
manager.remove(bean);
transaction.commit();
return true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
return false;
}
@Override
public List<EmployeeBean> getAllEmployees() {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
List<EmployeeBean> list = null;
try {
Query query = manager.createQuery(" from EmployeeBean ");
list = query.getResultList();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
return list;
}
@Override
public boolean addEmployee(EmployeeBean bean) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
EntityTransaction transaction = manager.getTransaction();
try {
if (bean != null) {
transaction.begin();
manager.persist(bean);
transaction.commit();
return true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
return false;
}
@Override
public boolean updateEmployee(EmployeeBean bean) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("springdb");
EntityManager manager = factory.createEntityManager();
EntityTransaction transaction = manager.getTransaction();
transaction.begin();
EmployeeBean info = manager.find(EmployeeBean.class, bean.getId());
if(bean.getName()!=null && bean.getName()!="") {
info.setName(bean.getName());
}
if(bean.getDob()!=null) {
info.setDob(bean.getDob());
}
if(bean.getPassword()!=null && bean.getPassword()!="") {
info.setPassword(bean.getPassword());
}
try {
if (bean != null) {
transaction.commit();
return true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (factory != null) {
factory.close();
}
if (manager != null) {
manager.close();
}
}
return false;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.