text stringlengths 10 2.72M |
|---|
package Services;
import DB.DBHandler;
import DB.Job;
import DB.Orchestration;
import LOG.LogClient;
import LOG.LogLevel;
import MainProcess.MainProcess;
import Services.Approve.ApproveService;
import Services.InfoService.InfoService;
import Services.Orchestration.OrchestrationService;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
@WebService(serviceName = "AdminService")
public class AdminService {
private String orchestrationServiceAddress;
private String infoServiceAddress;
private String approveServiceAddress;
private Endpoint orchestrationEndpoint;
private Endpoint infoEndpoint;
private Endpoint approveEndpoint;
public static boolean stopped;
private DBHandler dbHandler = new DBHandler();
public AdminService() {
String hostIp = getHostIp();
orchestrationServiceAddress = "http://" + hostIp + ":9001/OrchestrationService";
orchestrationEndpoint = Endpoint.publish(orchestrationServiceAddress, new OrchestrationService());
LogClient.LogDesc("Orchestration webservice has been started.", -1, LogLevel.INFO);
infoServiceAddress = "http://" + hostIp + ":9001/InfoService";
infoEndpoint = Endpoint.publish(infoServiceAddress, new InfoService());
LogClient.LogDesc("Infoservice webservice has been started.", -1, LogLevel.INFO);
approveServiceAddress = "http://" + hostIp + ":9001/ApproveService";
approveEndpoint = Endpoint.publish(approveServiceAddress, new ApproveService());
LogClient.LogDesc("Approveservice webservice has been started.", -1, LogLevel.INFO);
String adminServiceAddress = "http://" + hostIp + ":9001/AdminService";
Endpoint.publish(adminServiceAddress, this);
LogClient.LogDesc("Adminservice webservice has been started.", -1, LogLevel.INFO);
stopped = false;
// tek stringli LOG
}
@WebMethod
public String startServer() {
if (!orchestrationEndpoint.isPublished()) {
stopped = false;
orchestrationEndpoint = Endpoint.publish(orchestrationServiceAddress, new OrchestrationService());
infoEndpoint = Endpoint.publish(infoServiceAddress, new InfoService());
approveEndpoint = Endpoint.publish(approveServiceAddress, new ApproveService());
LogClient.LogDesc("Server has just been started", -1, LogLevel.INFO);
// tek stringli LOG //System.out.println("----> Server has been started!");
return "*** Server has just been started! ***";
}
return "*** Server is running now! ***";
}
@WebMethod
public String stopServer() {
if (orchestrationEndpoint.isPublished()) {
stopped = true;
updateOrchestrations();
updateJobs();
orchestrationEndpoint.stop();
infoEndpoint.stop();
approveEndpoint.stop();
LogClient.LogDesc("Server has just been stopped", -1, LogLevel.INFO);
// tek stringli LOG //System.out.println("----> Server has been stopped!");
return "*** Server has just been stopped! ***";
}
else {
LogClient.LogDesc("Server has just been stopped",-1, LogLevel.INFO);
// tek stringli LOG //System.out.println("----> Server has been stopped!");
return "*** Server was stopped! ***";
}
}
@WebMethod
public boolean getServerState() {
return stopped;
}
private void updateJobs() {
for (Job job : MainProcess.jobList) {
System.out.println("*----->job " + job.getId() + " ");
job.setStatus(StatusCodes.INITIAL);
try {
dbHandler.updateOrchestration(job.getId(), "Status", StatusCodes.INITIAL);
} catch (Exception e) {
e.printStackTrace();
}
}
}
private void updateOrchestrations() {
for (Orchestration orch : MainProcess.orchList) {
System.out.println("*----->orch " + orch.getId() + " ");
orch.setStatus(StatusCodes.INITIAL);
try {
dbHandler.updateOrchestration(orch.getId(), "Status", StatusCodes.INITIAL);
} catch (Exception e) {
e.printStackTrace();
}
}
}
private static String getHostIp(){
String ip="";
try(final DatagramSocket socket = new DatagramSocket()){
socket.connect(InetAddress.getByName("8.8.8.8"), 10002);
ip = socket.getLocalAddress().getHostAddress();
} catch (UnknownHostException | SocketException e) {
e.printStackTrace();
}
return ip;
}
}
|
package main.java.com.javacore.io_nio.task3.controller;
import java.util.HashSet;
import java.util.Set;
import main.java.com.javacore.io_nio.task3.controller.dto.AccountDto;
import main.java.com.javacore.io_nio.task3.controller.dto.DeveloperDto;
import main.java.com.javacore.io_nio.task3.controller.dto.ProjectDto;
import main.java.com.javacore.io_nio.task3.model.Account;
import main.java.com.javacore.io_nio.task3.model.Developer;
import main.java.com.javacore.io_nio.task3.model.Project;
/*
* Класс маппер. Из дто в сущность базы данных
* */
public final class DtoMapper {
static Project fromProjectDtoToEntity(ProjectDto projectDto) {
Project project = new Project();
Set<Developer> developers = new HashSet<>();
projectDto.getDevelopers().forEach(developerDto -> {
developers.add(fromDeveloperDtoToEntity(developerDto));
});
project.setProjectStatus(projectDto.getProjectStatus());
project.setDevelopers(developers);
if (projectDto.getId() != null) {
project.setId(projectDto.getId());
}
return project;
}
static Developer fromDeveloperDtoToEntity(DeveloperDto developerDto) {
Developer developer = new Developer();
developer.setAccount(fromAccDtoToEntity(developerDto.getAccount()));
return developer;
}
static Account fromAccDtoToEntity(AccountDto accountDto) {
Account account = new Account();
account.setData(accountDto.getData());
return account;
}
}
|
package org.squonk.client;
import org.squonk.core.user.User;
/**
* Created by timbo on 12/03/16.
*/
public interface UserClient {
User getUser(String username) throws Exception;
}
|
package com.driva.drivaapi.constant;
public class SecurityConstant {
public static final String ACCESS_DENIED_MESSAGE = "You do not have permission to access this page";
}
|
package com.xeon.jw;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class JwApplicationTests {
@Test
void contextLoads() {
}
}
|
package corgitaco.fabricnetworkutil.s2c;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.world.level.Level;
import java.util.function.BiConsumer;
import java.util.function.Function;
public interface S2CPacket {
void write(FriendlyByteBuf buf);
void handle(Level level);
record Handler<T extends S2CPacket>(Class<T> clazz, BiConsumer<T, FriendlyByteBuf> write,
Function<FriendlyByteBuf, T> read,
BiConsumer<T, Level> handle) {
}
} |
package friend.group.bank.obj.domain.member.repository;
import friend.group.bank.obj.domain.member.entity.Member;
import friend.group.bank.obj.domain.member.status.MemberAuthority;
import org.springframework.data.jpa.repository.JpaRepository;
public interface MemberJpaRepository extends JpaRepository<Member, Long> {
Member findByMemberAuthority(MemberAuthority memberAuthority);
}
|
package scut218.pisces.utils.impl;
import com.google.protobuf.ByteString;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoConnector;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.executor.ExecutorFilter;
import org.apache.mina.filter.keepalive.KeepAliveFilter;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.filter.ssl.SslFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scut218.pisces.network.MINA_ClientHandler;
import scut218.pisces.network.ProtoCodecFactory;
//import scut218.pisces.network.SSLContextGenerator;
import scut218.pisces.proto.MsgProtocol;
import scut218.pisces.utils.NetworkUtil;
import javax.net.ssl.SSLContext;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import static java.lang.Thread.sleep;
public class ClientNetworkImpl implements NetworkUtil{
private static IoSession session;
private static IoConnector connector;
//30S超时
private static final int IDLETIMEOUT = 30;
//15S心跳频率
private static final int HEARTBEATRATE = 15;
//心跳包内容
private static final MsgProtocol.msgProtocol.Builder HEARTBEATREQUESTB = MsgProtocol.msgProtocol.newBuilder().setFromWhom("Client").setToWhom("Server").setType(MsgProtocol.msgProtocol.Type.FUNREQ).addMsgD(MsgProtocol.msgProtocol.msgDetail.newBuilder().setMsgStream(ByteString.copyFromUtf8("SFATETZGWETRGSGRTSERWR")));
private static final byte[] HEARTBEATREQUEST = HEARTBEATREQUESTB.build().toByteArray();
private static final MsgProtocol.msgProtocol.Builder HEARTBEATRESPONSEB = MsgProtocol.msgProtocol.newBuilder().setFromWhom("Server").setToWhom("Client").setType(MsgProtocol.msgProtocol.Type.FUNREQ).addMsgD(MsgProtocol.msgProtocol.msgDetail.newBuilder().setMsgStream(ByteString.copyFromUtf8("RWEOPRPZIPEMFSEORIWORE")));
private static final byte[] HEARTBEATRESPONSE = HEARTBEATRESPONSEB.build().toByteArray();
private static final Logger Client_LOG = LoggerFactory.getLogger(ClientNetworkImpl.class);
private static final int PORT = 8088;
private static String HOST;
private static ClientNetworkImpl singleNetworkUtilImpl;
private static String User;
public synchronized void setUser(String usr)
{
User=usr;
}//设置User用于配置session.attribute
public static synchronized ClientNetworkImpl getsingleNetworkUtilImpl(){
if(singleNetworkUtilImpl==null)
{
singleNetworkUtilImpl=new ClientNetworkImpl();
}
return singleNetworkUtilImpl;
}
public IoSession getsession()
{
return session;
}
public void init(String host) {
try {
//创建连接
HOST=host;
connector = new NioSocketConnector();
//添加过滤器
// SSLContext sslContext = new SSLContextGenerator().getSslContext();
// SslFilter sslFilter = new SslFilter(sslContext);
// sslFilter.setUseClientMode(true);
//connector.getFilterChain().addFirst("sslFilter",sslFilter);
// connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"), LineDelimiter.WINDOWS.getValue(), LineDelimiter.WINDOWS.getValue())));
connector.getFilterChain().addLast("proto", new ProtocolCodecFilter(new ProtoCodecFactory()));
connector.getFilterChain().addLast("logger", new LoggingFilter());
connector.getFilterChain().addLast("threadPool",new ExecutorFilter(Executors.newCachedThreadPool()));
// 读写通道10秒内无操作进入空闲状态
connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, IDLETIMEOUT);
// 为接收器设置管理服务
KeepAliveMessageFactory heartBeatFactory = new ClientHeartBeatFactory();
KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory, IdleStatus.BOTH_IDLE);//BOTH_IDLE表示在读写通道都是空闲的时候开始计时心跳
//设置是否forward到下一个filter
heartBeat.setForwardEvent(true);
//设置心跳频率
heartBeat.setRequestInterval(HEARTBEATRATE);
//设置心跳超时
heartBeat.setRequestTimeout(5);
connector.getFilterChain().addLast("heartbeat", heartBeat);
connector.setHandler(new MINA_ClientHandler());
//创建连接
// ConnectFuture future = connector.connect(new InetSocketAddress(InetAddress.getLocalHost().getHostAddress(), PORT));
ConnectFuture future = connector.connect(new InetSocketAddress(HOST, PORT));
//System.out.println("IP地址是： " + InetAddress.getLocalHost().getHostAddress());
//等待链接创建完成
future.awaitUninterruptibly();
//获得session
session = future.getSession();
session.setAttribute("SessionTag", "13414478025");//Object setAttribute(Object key,Object value) key - the key of the attribute value - the value of the attribute
session.setAttribute("User",User);
System.out.println(session.getAttribute("SessionTag"));
} catch (Exception e) {
System.out.println("与服务器建立连接异常...");
e.printStackTrace();
}
}
public long send(MsgProtocol.msgProtocol msg) {
long id = msg.getId();
byte[] msgStream = msg.toByteArray();
session.write(msgStream);
System.out.println("writed");
return id;
}
public MsgProtocol.msgProtocol receive(long id) {
int i = 10;
while (i-- > 0) {
try {
sleep(1000);
if (MINA_ClientHandler.ClientMap.get(id) != null) {
MsgProtocol.msgProtocol msgProtocol = MINA_ClientHandler.ClientMap.get(id);
MINA_ClientHandler.ClientMap.remove(id);
return msgProtocol;
}
}catch (Exception e)
{
e.printStackTrace();
}
}
return null;
}
private static class ClientHeartBeatFactory implements KeepAliveMessageFactory
{
@Override
public boolean isResponse (IoSession session, Object message){
try {
MsgProtocol.msgProtocol msg = MsgProtocol.msgProtocol.parseFrom((byte[]) message);
if (msg.getMsgD(0).getMsgStream().toStringUtf8().equals(MsgProtocol.msgProtocol.parseFrom(HEARTBEATRESPONSE).getMsgD(0).getMsgStream().toStringUtf8()))//如果是心跳包，返回true
{
Client_LOG.info("收到服务端心跳回复包信息是: " + HEARTBEATRESPONSE);
System.out.println("wozaizhende");
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("wozaizheli");
return false;
}
@Override
public Object getRequest (IoSession session){
Client_LOG.info("客户端发出一个心跳请求包: " + HEARTBEATREQUEST);
/**发出一个包刷新SessionMap* */
session.write(MsgProtocol.msgProtocol.newBuilder().setFromWhom((String)session.getAttribute("User")).setToWhom("Server").setType(MsgProtocol.msgProtocol.Type.FUNREQ).addMsgD(MsgProtocol.msgProtocol.msgDetail.newBuilder().setType(MsgProtocol.msgProtocol.msgType.TEXT).setMsgName("little")).build().toByteArray());
/** 返回预设语句 */
return HEARTBEATREQUEST;
}
@Override
public boolean isRequest (IoSession session, Object message){//因为不会接收到请求，所以直接返回false
// LOG.info("获得的请求包信息是: " + message);
// if (message.equals(HEARTBEATREQUEST))//如果是心跳包，返回true
// return true;
return false;
}
@Override
public Object getResponse (IoSession session, Object request){
// LOG.info("获取一个心跳回复包: " + HEARTBEATRESPONSE);
// /** 返回预设语句 */
// return HEARTBEATRESPONSE;
return null;
}
}
}
|
package net.myinfosys.desembertraining.swing;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class FrameTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//create frame with name Frame
JFrame frame = new JFrame("HelloWorldSwing");
//add close widget
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//set size frame
frame.setSize(500, 500);
//set location on center
frame.setLocationRelativeTo(null);
//create component
//create button
JLabel label = new JLabel("Hello World");
JButton button = new JButton("Save");
//add component to frame
frame.add(button);
frame.add(label);
//run the frame
frame.setVisible(true);
}
}
|
package es.zamorano.popularmovielist.ui;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.squareup.picasso.Picasso;
import butterknife.BindView;
import butterknife.ButterKnife;
import es.zamorano.popularmovielist.R;
import es.zamorano.popularmovielist.models.Movie;
import io.realm.Realm;
public class MovieActivity extends AppCompatActivity {
@BindView(R.id.movie_activity_poster)
ImageView mMoviePoster;
@BindView(R.id.movie_activity_title)
TextView mMovieTittle;
@BindView(R.id.movie_activity_overview)
TextView mMovieOverview;
@BindView(R.id.movie_activity_vote)
TextView mMovieVote;
@BindView(R.id.fab_movie_activity)
FloatingActionButton mFab;
private Movie mMovieDatabase;
private Realm mRealm;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_movie);
ButterKnife.bind(this);
Realm.init(getApplicationContext());
mRealm = Realm.getDefaultInstance();
final Movie mMovie;
if (getIntent().hasExtra("movie")) {
mMovie = getIntent().getParcelableExtra("movie");
} else {
throw new IllegalArgumentException();
}
mMovieTittle.setText(mMovie.getTitle());
mMovieOverview.setText(mMovie.getOverview());
mMovieVote.setText(String.format(getString(R.string.vote_raiting), mMovie.getVote()));
Picasso.with(this)
.load(mMovie.getBackdrop())
.placeholder(R.color.colorPrimary)
.into(mMoviePoster);
mMovieDatabase = mRealm.where(Movie.class).equalTo("id", mMovie.getId()).findFirst();
if (mMovieDatabase != null)
mFab.setImageResource(R.drawable.ic_favorite);
mFab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mMovieDatabase != null) {
mRealm.beginTransaction();
mMovieDatabase.deleteFromRealm();
mRealm.commitTransaction();
mFab.setImageResource(R.drawable.ic_favorite_border);
} else {
mRealm.beginTransaction();
mMovieDatabase = mMovie;
mRealm.insert(mMovieDatabase);
mRealm.commitTransaction();
mFab.setImageResource(R.drawable.ic_favorite);
}
}
});
}
@Override
protected void onDestroy() {
super.onDestroy();
mRealm.close();
}
}
|
package entity;
public class DepotIn_select {
private String bdate;
private String edate;
private String in_id; //单号
private String vendor;
private String store;
private String state;
private String create;
private String src;
public String getBdate() {
return bdate;
}
public void setBdate(String bdate) {
this.bdate = bdate;
}
public String getEdate() {
return edate;
}
public void setEdate(String edate) {
this.edate = edate;
}
public String getIn_id() {
return in_id;
}
public void setIn_id(String in_id) {
this.in_id = in_id;
}
public String getVendor() {
return vendor;
}
public void setVendor(String vendor) {
this.vendor = vendor;
}
public String getStore() {
return store;
}
public void setStore(String store) {
this.store = store;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getCreate() {
return create;
}
public void setCreate(String create) {
this.create = create;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
@Override
public String toString() {
return "DepotIn_select{" +
"bdate='" + bdate + '\'' +
", edate='" + edate + '\'' +
", in_id='" + in_id + '\'' +
", vendor='" + vendor + '\'' +
", store='" + store + '\'' +
", state='" + state + '\'' +
", create='" + create + '\'' +
", src='" + src + '\'' +
'}';
}
}
|
package pl.teo.lib.controllers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import pl.teo.lib.entities.Category;
import pl.teo.lib.service.CategoryService;
import java.util.List;
@RestController
@RequestMapping("/api/category")
@CrossOrigin(origins = "http://localhost:4200")
public class CategoryController {
private final CategoryService categoryService;
@Autowired
public CategoryController(CategoryService categoryService) {
this.categoryService = categoryService;
}
@GetMapping("/{id}")
public Category getCategory(@PathVariable Long id) {
return categoryService.getById(id);
}
@DeleteMapping("/{id}")
public void deleteCategory(@PathVariable Long id) {
categoryService.deleteById(id);
}
@PostMapping()
public Category addCategory(@RequestBody Category category) {
return categoryService.save(category);
}
@PutMapping("/{id}")
public boolean editCategory(@PathVariable Long id, @RequestBody Category category) {
if (id.equals(category.getId())) {
categoryService.save(category);
return true;
}
return false;
}
@GetMapping()
public List<Category> getAll() {
return categoryService.getAll();
}
}
|
package com.mittidesign.initiativemanager;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DbHelper extends SQLiteOpenHelper {
// Logcat tag
public static final String LOG = "DatabaseHelper";
// Database Version
public static final int DB_VERSION = 1;
// Database Name
public static final String DB_NAME = "initiativemanager.db";
// Table Names
public static final String TABLE_FIGHTLIST = "fightlist";
public static final String TABLE_CHARLIST = "charlist";
//FIGHTLIST Column Names
public static final String COLUMN_FIGHT_ID = "id";
public static final String COLUMN_FIGHT_ACTIVE = "active";
public static final String COLUMN_FIGHT_NAME = "name";
public static final String COLUMN_FIGHT_INITIATIVE = "initiative";
public static final String COLUMN_FIGHT_HP = "hp";
public static final String COLUMN_FIGHT_STAMINA ="stamina";
public static final String COLUMN_FIGHT_NPC ="npc";
//CHARACTERLIST Column Names
public static final String COLUMN_CHAR_ID = "id";
public static final String COLUMN_CHAR_NAME = "name";
public static final String COLUMN_CHAR_HP = "hp";
public static final String COLUMN_CHAR_STAMINA ="stamina";
public static final String COLUMN_CHAR_NPC ="npc";
//Create Tables
//Create FIGHTLIST
public static final String CREATE_TABLE_FIGHTLIST =
"create table " + TABLE_FIGHTLIST + "(" +
COLUMN_FIGHT_ID + " integer primary key autoincrement, "+
COLUMN_FIGHT_ACTIVE + " text, "+
COLUMN_FIGHT_NAME + " text not null, "+
COLUMN_FIGHT_INITIATIVE + " integer, "+
COLUMN_FIGHT_HP + " integer, "+
COLUMN_FIGHT_STAMINA + " integer, "+
COLUMN_FIGHT_NPC + " integer);";
//Create CHARLIST
public static final String CREATE_TABLE_CHARLIST =
"create table " + TABLE_CHARLIST + "(" +
COLUMN_CHAR_ID + " integer primary key autoincrement, "+
COLUMN_CHAR_NAME + " text not null, "+
COLUMN_CHAR_HP + " integer, "+
COLUMN_CHAR_STAMINA + " integer, "+
COLUMN_CHAR_NPC + " integer);";
//Constructor
public DbHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
// creating required tables
db.execSQL(CREATE_TABLE_FIGHTLIST);
db.execSQL(CREATE_TABLE_CHARLIST);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// on upgrade drop older tables
db.execSQL("DROP TABLE IF EXISTS " + TABLE_FIGHTLIST);
db.execSQL("DROP TABLE IF EXISTS " + TABLE_CHARLIST);
// create new tables
onCreate(db);
}
}
|
/*
* Copyright 2018 Google LLC
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.gnd.ui.projectselector;
import android.util.Log;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import com.google.android.gnd.model.Project;
import com.google.android.gnd.repository.DataRepository;
import com.google.android.gnd.repository.Persistable;
import com.google.android.gnd.system.AuthenticationManager;
import com.google.android.gnd.ui.common.AbstractViewModel;
import io.reactivex.Single;
import io.reactivex.subjects.PublishSubject;
import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
public class ProjectSelectorViewModel extends AbstractViewModel {
private static final String TAG = ProjectSelectorViewModel.class.getSimpleName();
private final MutableLiveData<Persistable<List<Project>>> projectSummaries;
private final PublishSubject<Integer> projectSelections;
private final MutableLiveData<Project> activeProject;
private final MutableLiveData<Throwable> activateProjectErrors;
@Inject
ProjectSelectorViewModel(DataRepository dataRepository, AuthenticationManager authManager) {
this.projectSummaries = new MutableLiveData<>();
this.activeProject = new MutableLiveData<>();
this.activateProjectErrors = new MutableLiveData<>();
this.projectSelections = PublishSubject.create();
disposeOnClear(
projectSelections
.switchMapSingle(
idx ->
dataRepository
.activateProject(getProjectSummary(idx).getId())
.doOnError(this::onActiveProjectError)
.onErrorResumeNext(Single.never()))
.subscribe(activeProject::setValue));
AuthenticationManager.User user =
authManager.getUser().blockingFirst(AuthenticationManager.User.ANONYMOUS);
disposeOnClear(
dataRepository
.getProjectSummaries(user)
.subscribe(projectSummaries::setValue, this::onProjectSummariesError));
}
public LiveData<Persistable<List<Project>>> getProjectSummaries() {
return projectSummaries;
}
public LiveData<Throwable> getActivateProjectErrors() {
return activateProjectErrors;
}
public LiveData<Project> getActiveProject() {
return activeProject;
}
private Project getProjectSummary(int idx) {
return Persistable.getData(this.projectSummaries).orElse(Collections.emptyList()).get(idx);
}
private void onProjectSummariesError(Throwable t) {
Log.d(TAG, "Failed to retrieve project summaries.", t);
}
private void onActiveProjectError(Throwable t) {
Log.d(TAG, "Could not activate project.", t);
this.activateProjectErrors.setValue(t);
}
void activateProject(int idx) {
projectSelections.onNext(idx);
}
}
|
package network.nerve.swap;
import network.nerve.swap.utils.NerveCallback;
/**
* @author Niels
*/
public class JunitCase<T> {
/**
* @param key 用例标识
* @param params 参数列表
* @param want 预期结果
* @param wantEx 预期是否抛出异常
* @param exClass 抛出的是什么异常
* @param message 打印信息
*/
public JunitCase(String key, T obj, Object[] params, Object want, boolean wantEx, Class<? extends Exception> exClass, NerveCallback callBack) {
this.key = key;
this.obj = obj;
this.params = params;
this.want = want;
this.wantEx = wantEx;
this.exClass = exClass;
this.message = key + "测试完成";
this.callBack = callBack;
}
//用例标识
private String key;
//调用主体
private T obj;
// 参数列表
private Object[] params;
// 预期结果
private Object want;
// 是否抛出异常
private boolean wantEx;
// 抛出的是什么异常
private Class<? extends Exception> exClass;
// 打印信息
private String message;
private NerveCallback callBack;
public NerveCallback getCallBack() {
return callBack;
}
public void setCallBack(NerveCallback callBack) {
this.callBack = callBack;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
public Object[] getParams() {
return params;
}
public void setParams(Object[] params) {
this.params = params;
}
public Object getWant() {
return want;
}
public void setWant(Object want) {
this.want = want;
}
public boolean isWantEx() {
return wantEx;
}
public void setWantEx(boolean wantEx) {
this.wantEx = wantEx;
}
public Class<? extends Exception> getExClass() {
return exClass;
}
public void setExClass(Class<? extends Exception> exClass) {
this.exClass = exClass;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
|
/*
File: Fraction.java
Downloaded from: http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc/Fraction.java
This has been moved to the com.myronmarston.util package because JRuby seems
to have issues importing from an edu package.
Originally written by Doug Lea and released into the public domain.
This may be used for any purposes whatsoever without acknowledgment.
Thanks for the assistance and support of Sun Microsystems Labs,
and everyone contributing, testing, and using this code.
History:
Date Who What
7Jul1998 dl Create public version
11Oct1999 dl add hashCode
*/
/*
* Copyright 2008, Myron Marston <myron DOT marston AT gmail DOT com>
*
* This file is part of Fractal Composer.
*
* Fractal Composer is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* at your option any later version.
*
* Fractal Composer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Fractal Composer. If not, see <http://www.gnu.org/licenses/>.
*/
package com.myronmarston.util;
import com.myronmarston.music.notation.NotationNote;
import org.simpleframework.xml.*;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* An immutable class representing fractions as pairs of longs.
* Fractions are always maintained in reduced form.
**/
@Root
public class Fraction implements Cloneable, Comparable, java.io.Serializable {
@Attribute
/** The numerator of this fraction. */
protected final long numerator_;
@Attribute
/** The denominator of this fraction. */
protected final long denominator_;
private final static String FRACTION_CORE_REGEX_STRING_WITHOUT_EDGE_ASSERTIONS = "(%s(?:[1-9](?:\\d)*))(?:\\/([1-9](?:\\d)*))?";
private final static String FRACTION_CORE_REGEX_STRING = String.format("^%s$", FRACTION_CORE_REGEX_STRING_WITHOUT_EDGE_ASSERTIONS);
/** Regular expression string to parse a fraction string. */
public final static String FRACTION_REGEX_STRING = String.format(FRACTION_CORE_REGEX_STRING, "0|-?");
/** Regular expression string to parse a fraction string. */
public final static String NON_NEGATIVE_FRACTION_REGEX_STRING = String.format(FRACTION_CORE_REGEX_STRING, "0|");
/** Regular expression string to parse a fraction string that disallows zeros. */
public final static String POSITIVE_FRACTION_REGEX_STRING = String.format(FRACTION_CORE_REGEX_STRING, "");
/** Regular expression string to parse a fraction in the midst of other test. */
public final static String POSITIVE_FRACTION_REGEX_STRING_WITHOUT_EDGE_ASSERTIONS = String.format(FRACTION_CORE_REGEX_STRING_WITHOUT_EDGE_ASSERTIONS, "");
/** Regular expression pattern to parse a fraction string. */
private final static Pattern FRACTION_REGEX_PATTERN = Pattern.compile(FRACTION_REGEX_STRING);
/**
* The maximum duration denominator supported by lilypond.
*/
public static final long MAX_ALLOWED_DURATION_DENOM = 64L;
/**
* The symbol that represents a tie in lilypond notation.
*/
private static final String LILYPOND_TIE = " ~ ";
/**
* The character used to augment rhythmic durations in lilypond notation.
*/
private static final char LILYPOND_AUGMENTATION_CHAR = '.';
/** Return the numerator **/
public final long numerator() { return numerator_; }
/** Return the denominator **/
public final long denominator() { return denominator_; }
/** Exists to allow xml deserialization using the simple framework **/
private Fraction() {
this(0, 1);
};
/**
* Constructs a fraction by parsing a fraction string.
*
* @param fractionStr a string in fraction ("1/4") or integer ("23") form
* @throws IllegalArgumentException if the string does not match
* the expected pattern or if the denominator is zero
*/
public Fraction(String fractionStr) throws IllegalArgumentException {
Matcher match = FRACTION_REGEX_PATTERN.matcher(fractionStr);
if (!match.matches()) throw new IllegalArgumentException("The fraction string '" + fractionStr + "' is not in a recognized form.");
String numStr = match.group(1);
String denStr = match.group(2);
Long num = Long.parseLong(numStr);
Long den = (denStr == null || denStr.isEmpty() ? 1L : Long.parseLong(denStr));
// the code below is copied from the other constructor.
// it would be better to make a helper method with this logic,
// but numerator_ and denominator_ are final, so we can only set them
// in a constructor. Besides, this code has been well tested, so there is
// no reason to expect this to ever change.
// normalize while constructing
boolean numNonnegative = (num >= 0);
boolean denNonnegative = (den >= 0);
long a = numNonnegative? num : -num;
long b = denNonnegative? den : -den;
long g = gcd(a, b);
numerator_ = (numNonnegative == denNonnegative)? (a / g) : (-a / g);
denominator_ = b / g;
}
/** Create a Fraction equal in value to num / den **/
public Fraction(long num, long den) throws IllegalArgumentException {
if (den == 0L) throw new IllegalArgumentException("The fraction denominator cannot be zero.");
// normalize while constructing
boolean numNonnegative = (num >= 0);
boolean denNonnegative = (den >= 0);
long a = numNonnegative? num : -num;
long b = denNonnegative? den : -den;
long g = gcd(a, b);
numerator_ = (numNonnegative == denNonnegative)? (a / g) : (-a / g);
denominator_ = b / g;
}
/** Create a fraction with the same value as Fraction f **/
public Fraction(Fraction f) {
numerator_ = f.numerator();
denominator_ = f.denominator();
}
/**
* Gets a string representation of this fraction.
*
* @return a string
*/
public String toString() {
if (denominator() == 1)
return "" + numerator();
else
return numerator() + "/" + denominator();
}
/**
* Gets a string representation of this fraction in GUIDO notation for a
* note duration.
*
* @return the guido string
*/
public String toGuidoString() {
if (this.numerator() == 1L) return "/" + this.denominator();
return "*" + this.toString();
}
/**
* Gets a string representing this duration fraction in lilypond notation.
* The string will have format placeholders for where the rest of the lilypond
* notation note should go.
*
* @param timeLeftInBar the amount of time that is left in the current bar,
* in absolute terms (i.e. not scaled by the tupletMultiplier)
* @param barLength the length of a bar in absolute terms (i.e. not scaled by
* the tuplet multiplier)
* @param tupletMultiplier the tuplet multiplier that has been applied
* to this notation note duration
* @return the lilypond duration string for the given duration
* @throws IllegalArgumentException if the dnominator of the duration is
* greater than the miximum supported by lilypond
* @throws UnsupportedOperationException if the duration is a tuplet
* duration
*/
public String toLilypondString(Fraction timeLeftInBar, Fraction barLength, Fraction tupletMultiplier) throws IllegalArgumentException, UnsupportedOperationException {
String lilypondString = toLilypondString(timeLeftInBar, barLength, tupletMultiplier, true);
// Lilypond blows up when a note with a tuplet multiplier is tied to another note,
// such as '/times 2/3 { c4 } ~ d4'. We'll remove the tie here, which isn't strictly
// the correct notation, but it's better to have lilypond produce something than nothing...
if (lilypondString.contains("times")) lilypondString = lilypondString.replaceAll(LILYPOND_TIE, " ");
// we should only have the dynamic placeholder once in this string...
assert lilypondString.contains(NotationNote.NOTE_PLACEHOLDER_2) : lilypondString;
assert lilypondString.lastIndexOf(NotationNote.NOTE_PLACEHOLDER_2) == lilypondString.indexOf(NotationNote.NOTE_PLACEHOLDER_2) : lilypondString;
// the dynamic place holder should only be on the first of all the tied
// notes, so check that it is before the tie string...
assert !lilypondString.contains(LILYPOND_TIE) || lilypondString.indexOf(NotationNote.NOTE_PLACEHOLDER_2) < lilypondString.indexOf(LILYPOND_TIE);
return lilypondString;
}
private String toLilypondString(Fraction timeLeftInBar, Fraction barLength, Fraction tupletMultiplier, boolean firstNoteInListOfTiedNotes) throws IllegalArgumentException, UnsupportedOperationException {
if (this.denominator_ > MAX_ALLOWED_DURATION_DENOM) throw new IllegalArgumentException("The given duration (" + this.toString() + ") has a denominator that is outside of the allowed range. The denominator cannot be greater than " + MAX_ALLOWED_DURATION_DENOM + ".");
assert timeLeftInBar.compareTo(barLength) <= 0 : timeLeftInBar;
if (!denomIsPowerOf2()) {
// We shouldn't actually get here for tuplet notes--instead, we'll
// get here when a non-tuplet note is split across a bar, splitting
// at an irregular point, i.e. splitting 1/4 into 1/6 | 1/12.
// We'll wrap the note in an appropriate tuplet multiplier in this case.
Fraction desiredFraction = new Fraction(1, MathHelper.getLargestPowerOf2LessThanGivenNumber(this.denominator_));
Fraction tupletMultiplierForThisFraction = this.dividedBy(desiredFraction);
tupletMultiplier = tupletMultiplier.times(tupletMultiplierForThisFraction);
return "\\times " +
tupletMultiplierForThisFraction.toString() +
" { " +
desiredFraction.toLilypondString(timeLeftInBar, barLength, tupletMultiplier, firstNoteInListOfTiedNotes) +
" }";
}
// if there is no time left in the bar, start a whole new bar...
if (timeLeftInBar.numerator_ == 0) timeLeftInBar = barLength;
Fraction tupletScaledTimeLeftInBar = timeLeftInBar.dividedBy(tupletMultiplier);
// this notationDuration should already be tuplet scaled, so compare it to the tupletScaledTimeLeftInBar...
if (this.compareTo(tupletScaledTimeLeftInBar) > 0) {
// this duration lasts longer than the time we have left in the bar,
// so we need to split it and use a tie to connect
Fraction tupletScaledRemaining = this.minus(tupletScaledTimeLeftInBar);
return tupletScaledTimeLeftInBar.toLilypondString(timeLeftInBar, barLength, tupletMultiplier, true && firstNoteInListOfTiedNotes)
+ LILYPOND_TIE +
tupletScaledRemaining.toLilypondString(barLength, barLength, tupletMultiplier, false);
} else {
// we only want to put a dynamic or articulation marking on the first
// note of the tied notes, so we have a special place holder for that
String afterFirstNoteString = (firstNoteInListOfTiedNotes ? NotationNote.NOTE_PLACEHOLDER_2 : "");
// take care of the easy cases: notes such as 1/4, 1/8, and
// notes using augmentation dots (3/8, 7/16, etc).
switch ((int) this.numerator_) {
case 1: return NotationNote.NOTE_PLACEHOLDER +
Long.toString(this.denominator_) +
afterFirstNoteString;
case 3: if (this.denominator_ < 2) break;
return NotationNote.NOTE_PLACEHOLDER +
Long.toString(this.denominator_ / 2) +
LILYPOND_AUGMENTATION_CHAR +
afterFirstNoteString;
case 7: if (this.denominator_ < 4) break;
return NotationNote.NOTE_PLACEHOLDER +
Long.toString(this.denominator_ / 4) +
LILYPOND_AUGMENTATION_CHAR +
LILYPOND_AUGMENTATION_CHAR +
afterFirstNoteString;
}
// split the duration into two seperate durations that can be tied together
Fraction d1 = this.getLargestPowerOf2FractionThatIsLessThanThis();
// if splitting it this way gives us a duration longer than our time left in the bar,
// just use the time left in the bar instead...
if (d1.compareTo(timeLeftInBar) > 0) d1 = timeLeftInBar;
Fraction d2 = this.minus(d1);
Fraction timeLeftInBar2 = timeLeftInBar.minus(d1);
assert timeLeftInBar2.compareTo(0L) >= 0 : timeLeftInBar2;
return d1.toLilypondString(timeLeftInBar, barLength, tupletMultiplier, true && firstNoteInListOfTiedNotes)
+ LILYPOND_TIE +
d2.toLilypondString(timeLeftInBar2, barLength, tupletMultiplier, false);
}
}
/**
* Clones this fraction.
*
* @return the clone
*/
@Override
public Fraction clone() {
try {
return (Fraction) super.clone();
} catch (CloneNotSupportedException ex) {
// We have implemented the Cloneable interface, so we should never
// get this exception. If we do, there's something very, very wrong...
throw new UndeclaredThrowableException(ex, "Unexpected error while cloning. This indicates a programming or JVM error.");
}
}
/** Return the value of the Fraction as a double **/
public double asDouble() {
return ((double)(numerator())) / ((double)(denominator()));
}
/**
* Compute the nonnegative greatest common divisor of a and b.
* (This is needed for normalizing Fractions, but can be
* useful on its own.)
**/
public static long gcd(long a, long b) {
long x;
long y;
if (a < 0) a = -a;
if (b < 0) b = -b;
if (a >= b) { x = a; y = b; }
else { x = b; y = a; }
while (y != 0) {
long t = x % y;
x = y;
y = t;
}
return x;
}
/** return a Fraction representing the negated value of this Fraction **/
public Fraction negative() {
long an = numerator();
long ad = denominator();
return new Fraction(-an, ad);
}
/** return a Fraction representing 1 / this Fraction **/
public Fraction inverse() {
long an = numerator();
long ad = denominator();
return new Fraction(ad, an);
}
/** return a Fraction representing this Fraction plus b **/
public Fraction plus(Fraction b) {
long an = numerator();
long ad = denominator();
long bn = b.numerator();
long bd = b.denominator();
return new Fraction(an*bd+bn*ad, ad*bd);
}
/** return a Fraction representing this Fraction plus n **/
public Fraction plus(long n) {
long an = numerator();
long ad = denominator();
long bn = n;
long bd = 1;
return new Fraction(an*bd+bn*ad, ad*bd);
}
/** return a Fraction representing this Fraction minus b **/
public Fraction minus(Fraction b) {
long an = numerator();
long ad = denominator();
long bn = b.numerator();
long bd = b.denominator();
return new Fraction(an*bd-bn*ad, ad*bd);
}
/** return a Fraction representing this Fraction minus n **/
public Fraction minus(long n) {
long an = numerator();
long ad = denominator();
long bn = n;
long bd = 1;
return new Fraction(an*bd-bn*ad, ad*bd);
}
/** return a Fraction representing this Fraction times b **/
public Fraction times(Fraction b) {
long an = numerator();
long ad = denominator();
long bn = b.numerator();
long bd = b.denominator();
return new Fraction(an*bn, ad*bd);
}
/** return a Fraction representing this Fraction times n **/
public Fraction times(long n) {
long an = numerator();
long ad = denominator();
long bn = n;
long bd = 1;
return new Fraction(an*bn, ad*bd);
}
/** return a Fraction representing this Fraction divided by b **/
public Fraction dividedBy(Fraction b) {
long an = numerator();
long ad = denominator();
long bn = b.numerator();
long bd = b.denominator();
return new Fraction(an*bd, ad*bn);
}
/** return a Fraction representing this Fraction divided by n **/
public Fraction dividedBy(long n) {
long an = numerator();
long ad = denominator();
long bn = n;
long bd = 1;
return new Fraction(an*bd, ad*bn);
}
/** return a number less, equal, or greater than zero
* reflecting whether this Fraction is less, equal or greater than
* the value of Fraction other.
**/
public int compareTo(Object other) {
Fraction b = (Fraction)(other);
long an = numerator();
long ad = denominator();
long bn = b.numerator();
long bd = b.denominator();
long l = an*bd;
long r = bn*ad;
return (l < r)? -1 : ((l == r)? 0: 1);
}
/**
* Returns a number less, equal, or greater than zero
* reflecting whether this Fraction is less, equal or greater than n.
*
* @param n the number to compare to
* @return value indicating whether this fraction is less, equal to or greater
* than n
*/
public int compareTo(long n) {
long an = numerator();
long ad = denominator();
long bn = n;
long bd = 1;
long l = an*bd;
long r = bn*ad;
return (l < r)? -1 : ((l == r)? 0: 1);
}
/**
* Tests if this fraction equals the passed value.
*
* @param other the value to check for equality
* @return true if the objects are equal
*/
@Override
public boolean equals(Object other) {
if (!(other instanceof Fraction)) return false;
return compareTo((Fraction)other) == 0;
}
/**
* Tests if this fraction equals the passed value.
*
* @param n the value to check for equality
* @return true if the objects are equal
*/
public boolean equals(long n) {
return compareTo(n) == 0;
}
/**
* Gets a hash code for this fraction.
*
* @return the hash code
*/
@Override
public int hashCode() {
return (int) (numerator_ ^ denominator_);
}
/**
* Checks to see if the denominator is a pwer of 2.
*
* @return true if the denominator is a power of 2
*/
public boolean denomIsPowerOf2() {
return MathHelper.numIsPowerOf2(this.denominator_);
}
/**
* Gets the largest fraction that is less than this fraction and has a
* denominator that is a power of 2. This function assumes the denominator
* already is a power of 2 and the numerator is greater than 1.
*
* @return the largest fraction less than this fraction with a denominator
* power of 2
* @throws UnsupportedOperationException if the fraction's denominator is not
* a power of 2 or the numerator is less than or equal to 1.
*/
public Fraction getLargestPowerOf2FractionThatIsLessThanThis() throws UnsupportedOperationException {
if (!this.denomIsPowerOf2() || this.numerator_ <= 1L) {
throw new UnsupportedOperationException("This method is not supported on this fraction (" + this.toString() + "). It is only supported on fractions that have a denominator power of 2 and a numerator greater than 1.");
}
Fraction subtractionAmount = new Fraction(1, this.denominator_);
Fraction test = this.minus(subtractionAmount);
while (!MathHelper.numIsPowerOf2(test.denominator_)) {
test = test.minus(subtractionAmount);
// We don't intend this to ever return a 0 or negative fraction...
assert test.numerator_ > 0 : test.numerator_;
}
return test;
}
}
|
package com.classroom.app.tests;
import com.classroom.app.Interfaces.MessageInterface;
import com.classroom.app.model.Message;
import com.classroom.app.services.MessageService;
import java.util.ArrayList;
import java.util.List;
/**
* Created by Muhammad Sadiq Saeed on 4/5/2017.
*/
public class Test6 {
public static void main(String[] args) {
MessageInterface messageInterface = new MessageService();
//messageInterface.sendMessage(1, "Hai man whats up", "cxlz11", "abcdefghijkl");
List<Message> messageList;
messageList = messageInterface.getAllMessages("abcdefgh1234");
for (Message m : messageList) {
System.out.println(" " + m);
}
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.dawningdevelopers.swing.util.windowstab;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
/**
*
* @author allon_000
*/
public class TabPane extends JPanel {
@Override
public void paintComponent(Graphics g) {
g.setColor(Color.WHITE);
g.fillRect(0, 0, getWidth(), getHeight());
}
}
|
package com.zafkiel.Proxy;
public interface TestProxy {
void count();
}
|
package edu.uclm.esi.common.androidClient.http;
import java.util.concurrent.ExecutionException;
import org.json.JSONException;
import org.json.JSONObject;
import edu.uclm.esi.common.jsonMessages.JSONMessage;
public class Proxy {
public static String PREFIX = "--", LINE_END = "\r\n";
private static Proxy yo;
private String urlServer;
private Proxy() {
this.urlServer = "172.19.154.49:8080";
}
public static Proxy get() {
if (yo==null)
yo=new Proxy();
return yo;
}
public void postJSONOrderWithNoResponse(String resource, JSONObject jso) throws JSONException {
PostJSONDataWithNoResponse pd=new PostJSONDataWithNoResponse(resource);
pd.execute(jso);
}
public JSONMessage postJSONOrderWithResponse(String resource) throws JSONException, InterruptedException, ExecutionException {
PostJSONDataWithResponse pd=new PostJSONDataWithResponse(resource);
pd.execute();
JSONMessage resp = pd.get();
return resp;
}
public JSONMessage postJSONOrderWithResponse(String resource, JSONMessage... jso) throws JSONException, InterruptedException, ExecutionException {
PostJSONDataWithResponse pd=new PostJSONDataWithResponse(resource);
pd.execute(jso);
JSONMessage resp = pd.get();
return resp;
}
public String getUrlServer() {
return urlServer;
}
}
|
package com.example.itime;
import android.content.Context;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class timeSaver {
Context context;
ArrayList<Time> times =new ArrayList<Time>();
public timeSaver(Context context) {
this.context = context;
}
public ArrayList<Time> getTimes() {
return times;
}
public void save(){
try {
ObjectOutputStream outputStream = new ObjectOutputStream(context.openFileOutput("Serializable.txt",Context.MODE_PRIVATE));
outputStream.writeObject(times);
outputStream.close(); //对象的序列化
}catch(Exception e){
e.printStackTrace();
}
}
public ArrayList<Time> load(){
try{
ObjectInputStream inputStream = new ObjectInputStream(context.openFileInput("Serializable.txt"));
times = (ArrayList<Time>) inputStream.readObject();
inputStream.close(); //对象的反序列化
}catch(Exception e){
e.printStackTrace();
}
return times;
}
}
|
package com.vipvideo.util;
import android.content.Context;
import android.graphics.Bitmap;
import android.net.http.SslError;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.webkit.CookieManager;
import android.webkit.CookieSyncManager;
import android.webkit.SslErrorHandler;
import android.webkit.WebChromeClient;
import android.webkit.WebResourceResponse;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.FrameLayout;
import com.vipvideo.R;
import java.util.Timer;
import java.util.TimerTask;
import java.util.regex.Pattern;
/**
* Created by Administrator on 2018/3/22.
*/
public class ParseWebView extends FrameLayout {
private WebView mWebView;
private final static String USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36";
public String mideaReg = ".*(.+\\.m3u8|.+\\.mp4|.+\\.flv).*";
OnParseWebUrlListener parseWebUrlListener;
InterceptRequest interceptRequest;
String finalUrl;
boolean isFinish;
public interface InterceptRequest {
WebResourceResponse shouldInterceptRequest(WebView view, String url);
}
public interface OnParseWebUrlListener {
void onFindUrl(String finalUrl);
void onError(String msg);
}
public void setOnParseListener(OnParseWebUrlListener parseListener) {
this.parseWebUrlListener = parseListener;
}
public ParseWebView(Context context) {
this (context, null);
}
public ParseWebView(Context context, AttributeSet attrs) {
this (context, attrs, 0);
}
public ParseWebView(Context context, AttributeSet attrs, int defStyleAttr) {
super (context, attrs, defStyleAttr);
initView (context);
}
private void initView(Context context) {
if (!isInEditMode ( )) {
View view = View.inflate(context, R.layout.item_parse_webview, null);
mWebView = view.findViewById (R.id.web_view);
addView (view);
initWebSettings ( );
}
}
private void initWebSettings() {
mWebView.clearFocus ( );
mWebView.setVisibility (INVISIBLE);
WebSettings mWebSettings = mWebView.getSettings ( );
mWebSettings.setJavaScriptEnabled (true);
mWebSettings.setDefaultTextEncodingName ("utf-8");
mWebSettings.setCacheMode (WebSettings.LOAD_DEFAULT);
mWebSettings.setPluginState (WebSettings.PluginState.ON);
mWebSettings.setDisplayZoomControls (false);
mWebSettings.setUseWideViewPort (true);
mWebSettings.setAllowFileAccess (true);
mWebSettings.setAllowContentAccess (true);
mWebSettings.setSupportZoom (true);
mWebSettings.setAllowContentAccess (true);
mWebSettings.setLoadWithOverviewMode (true);
mWebSettings.setBuiltInZoomControls (true);// 隐藏缩放按钮
mWebSettings.setUseWideViewPort (true);// 可任意比例缩放
mWebSettings.setLoadWithOverviewMode (true);// setUseWideViewPort方法设置webview推荐使用的窗口。setLoadWithOverviewMode方法是设置webview加载的页面的模式。
mWebSettings.setSavePassword (true);
mWebSettings.setSaveFormData (true);// 保存表单数据
mWebSettings.setJavaScriptEnabled (true);
mWebSettings.setTextZoom (100);
mWebSettings.setDomStorageEnabled (true);
mWebSettings.setSupportMultipleWindows (true);// 新加//我就是没有这一行，死活不出来。MD，硬是没有人写这一句！
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
mWebSettings.setMixedContentMode (WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
mWebSettings.setMediaPlaybackRequiresUserGesture (true);
}
if (Build.VERSION.SDK_INT >= 16) {
mWebSettings.setAllowFileAccessFromFileURLs (true);
mWebSettings.setAllowUniversalAccessFromFileURLs (true);
}
mWebSettings.setJavaScriptCanOpenWindowsAutomatically (true);
mWebSettings.setAppCacheEnabled (false);
mWebSettings.setDatabaseEnabled (true);
mWebSettings.setGeolocationDatabasePath (getContext ( ).getDir ("database", 0).getPath ( ));
mWebSettings.setGeolocationEnabled (false);
enabledCookie (mWebView);//启用cookie
mWebView.setWebViewClient (new MyWebViewClient ( ));
mWebView.setWebChromeClient(new WebChromeClient());
}
public void loadUrl(String url) {
mWebView.loadUrl (url);
}
/*启用cookie*/
private void enabledCookie(WebView web) {
CookieManager instance = CookieManager.getInstance ( );
if (Build.VERSION.SDK_INT < 21) {
CookieSyncManager.createInstance (getContext ( ));
}
instance.setAcceptCookie (true);
if (Build.VERSION.SDK_INT >= 21) {
instance.setAcceptThirdPartyCookies (web, true);
}
}
private class MyWebViewClient extends WebViewClient {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
if (url.startsWith("intent") || url.startsWith("youku")) {
return true;
} else {
return super.shouldOverrideUrlLoading(view, url);
}
}
/*解决ssl证书问题*/
@Override
public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
handler.proceed();
}
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
Log.e("shouldInterceptRequest", url);
if (Pattern.matches(mideaReg, url)) {
finalUrl = url;
isFinish = true;
// 获取页面内容
if (parseWebUrlListener != null) {
Log.e("onProgressChanged", finalUrl + "");
parseWebUrlListener.onFindUrl(finalUrl);
}
}
if (interceptRequest != null) {
return interceptRequest.shouldInterceptRequest(view, url);
}
return super.shouldInterceptRequest(view, url);
}
@Override
public void onPageStarted(WebView view, String url, Bitmap favicon) {
super.onPageStarted(view, url, favicon);
startCount();//加载超时处理
}
@Override
public void onPageFinished(WebView view, String url) {
super.onPageFinished(view, url);
Log.e("onPageFinished", finalUrl + "");
}
}
/*解决webview加载超时问题*/
private void startCount() {
final Timer timer = new Timer();
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
timer.cancel();
timer.purge();
if (parseWebUrlListener != null && !isFinish) {
parseWebUrlListener.onError(null);
}
}
};
timer.schedule(timerTask, 20 * 1000, 1);
}
public void onDestroy() {
if (mWebView != null) {
mWebView.stopLoading();
mWebView.destroy();
mWebView.clearHistory();
}
}
public void setInterceptRequest(ParseWebView.InterceptRequest interceptRequest) {
this.interceptRequest = interceptRequest;
}
}
|
package net.datacrow.core.modules;
import net.datacrow.console.ComponentFactory;
import net.datacrow.core.DcRepository;
import net.datacrow.core.modules.xml.XmlModule;
import net.datacrow.core.objects.DcAssociate;
import net.datacrow.core.objects.DcField;
import net.datacrow.core.objects.DcObject;
public class DcAssociateModule extends DcModule {
/**
* Creates a new instance.
* @param index The module index.
* @param topModule Indicates if the module is a top module. Top modules are allowed
* to be displayed in the module bar and can be enabled or disabled.
* @param name The internal unique name of the module.
* @param description The module description
* @param objectName The name of the items belonging to this module.
* @param objectNamePlural The plural name of the items belonging to this module.
* @param tableName The database table name for this module.
* @param tableShortName The database table short name for this module.
*/
public DcAssociateModule(int index,
String name,
String description,
String objectName,
String objectNamePlural,
String tableName,
String tableShortName) {
super(index, false, name, description, objectName, objectNamePlural,
tableName, tableShortName);
}
@Override
public int getDisplayFieldIdx() {
return DcAssociate._A_NAME;
}
/**
* Creates this module based on an XML module definition.
* @param module
*/
public DcAssociateModule(XmlModule module) {
super(module);
}
@Override
public boolean isContainerManaged() {
return false;
}
/**
* Indicates whether this module be selected from the module bar.
*/
@Override
public boolean isSelectableInUI() {
return false;
}
@Override
public int getDefaultSortFieldIdx() {
return DcAssociate._A_NAME;
}
@Override
public boolean isTopModule() {
return true;
}
/**
* Creates a new instance of an item belonging to this module.
*/
@Override
public DcObject createItem() {
return new DcAssociate(getIndex());
}
@Override
protected void initializeFields() {
super.initializeFields();
addField(new DcField(DcAssociate._A_NAME, getIndex(), "Name",
false, true, false, true,
255, ComponentFactory._SHORTTEXTFIELD, getIndex(), DcRepository.ValueTypes._STRING,
"Name"));
addField(new DcField(DcAssociate._B_DESCRIPTION, getIndex(), "Description",
false, true, false, true,
4000, ComponentFactory._LONGTEXTFIELD, getIndex(), DcRepository.ValueTypes._STRING,
"Description"));
addField(new DcField(DcAssociate._C_WEBPAGE, getIndex(), "Webpage",
false, true, false, true,
255, ComponentFactory._URLFIELD, getIndex(), DcRepository.ValueTypes._STRING,
"webpage"));
addField(new DcField(DcAssociate._D_PHOTO, getIndex(), "Photo",
true, true, false, false,
0, ComponentFactory._PICTUREFIELD, getIndex(), DcRepository.ValueTypes._PICTURE,
"Photo"));
addField(new DcField(DcAssociate._E_FIRSTNAME, getIndex(), "Firstname",
false, true, false, true,
255, ComponentFactory._SHORTTEXTFIELD, getIndex(), DcRepository.ValueTypes._STRING,
"Firstname"));
addField(new DcField(DcAssociate._F_LASTTNAME, getIndex(), "Lastname",
false, true, false, true,
255, ComponentFactory._SHORTTEXTFIELD, getIndex(), DcRepository.ValueTypes._STRING,
"Lastname"));
getField(DcObject._ID).setEnabled(false);
}
@Override
public boolean equals(Object o) {
return (o instanceof DcAssociateModule ? ((DcAssociateModule) o).getIndex() == getIndex() : false);
}
}
|
package com.example.khoa.models;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;
/**
* Created by khoa.nguyen on 2/29/2016.
*/
public class PostDatabaseHelper extends SQLiteOpenHelper {
/* Database info */
private static final String DATABASE_NAME = "postsDatabase";
private static final int DATABASE_VERSION = 1;
/* Table name */
private static final String TABLE_POSTS = "posts";
/* Post table column */
private static final String KEY_POST_ID = "id";
private static final String KEY_POST_CONTENT = "content";
private static final String TAG = "PostDatabase";
private static PostDatabaseHelper sInstance;
/*
* Use the application context, which will ensure that you
* don't accidentally leak an Activity's context.
*/
public static synchronized PostDatabaseHelper getsInstance(Context context) {
if (sInstance == null) {
sInstance = new PostDatabaseHelper(context.getApplicationContext());
}
return sInstance;
}
/**
* @param context
*/
private PostDatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_POSTS_TABLE = "CREATE TABLE " + TABLE_POSTS +
"(" +
KEY_POST_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," + // Define a primary key
KEY_POST_CONTENT + " TEXT NOT NULL" +
")";
db.execSQL(CREATE_POSTS_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
if (oldVersion != newVersion) {
Log.w(TAG, "Upgrading database. Existing contents will be lost. ["
+ oldVersion + "] -> [" + newVersion + "]");
db.execSQL("DROP TABLE IF EXISTS " + TABLE_POSTS);
onCreate(db);
}
}
/* Insert the post into database */
public int create(Post post) {
// Create and/or open the database for writing
SQLiteDatabase db = getWritableDatabase();
ContentValues values = new ContentValues();
values.put(KEY_POST_CONTENT, post.content);
int id = (int) db.insert(TABLE_POSTS, null, values);
db.close();
return id;
}
// Get all posts in the database
public List<Post> getAllPosts() {
List<Post> posts = new ArrayList<>();
// SELECT * FROM POSTS
// LEFT OUTER JOIN USERS
// ON POSTS.KEY_POST_USER_ID_FK = USERS.KEY_USER_ID
String POSTS_SELECT_QUERY =
String.format("SELECT * FROM %s ORDER BY id DESC",
TABLE_POSTS
);
// "getReadableDatabase()" and "getWriteableDatabase()" return the same object (except under low
// disk space scenarios)
SQLiteDatabase db = getReadableDatabase();
Cursor cursor = db.rawQuery(POSTS_SELECT_QUERY, null);
try {
if (cursor.moveToFirst()) {
do {
Post newPost = new Post();
newPost.setContent(cursor.getString(cursor.getColumnIndex(KEY_POST_CONTENT)));
newPost.setId(cursor.getInt(cursor.getColumnIndex(KEY_POST_ID)));
posts.add(newPost);
} while(cursor.moveToNext());
}
} catch (Exception e) {
Log.d(TAG, "Error while trying to get posts from database");
} finally {
if (cursor != null && !cursor.isClosed()) {
cursor.close();
}
}
return posts;
}
/* Update the post */
public int updatePost(Post post) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(KEY_POST_CONTENT, post.content);
// Updating post with KEY_ID
return db.update(TABLE_POSTS, values, KEY_POST_ID + " = ?",
new String[] { String.valueOf(post.getId()) });
}
/* Delete the post */
public void deletePost(Post post) {
SQLiteDatabase db = this.getWritableDatabase();
db.delete(TABLE_POSTS, KEY_POST_ID + " = ?", new String[]{String.valueOf(post.getId())});
db.close();
}
}
|
import java.util.LinkedList;
/** NFlist.java
*
* Author: Greg Choice c9311718@uon.edu.au
*
* Created:
* Updated: 28/09/2018
*
* Description:
* STNode sub-class for NFLIST rule
*
*/
public class NFlist extends STNode
{
public NFlist(LinkedList<Token> tokenList, SymbolTable table)
{
super(NID.NFLIST);
setRight(processFlist(tokenList, table));
}
}
|
package com.pointinside.android.api.maps;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
public class PIMapOverlayItem
implements PIMapAnnotation
{
private Rect mHitBounds;
protected PIMapLocation mLocation;
protected Drawable mMarker;
private long mPromoId = -1L;
private int mPromoType = -1;
private Rect mRelativeBounds;
private final long mSpecialAreaId;
protected String mSubTitle;
protected String mTitle;
private final int mZoneIndex;
public PIMapOverlayItem(PIMapLocation paramPIMapLocation, String paramString1, String paramString2, int paramInt)
{
this.mLocation = paramPIMapLocation;
this.mTitle = paramString1;
this.mSubTitle = paramString2;
this.mZoneIndex = paramInt;
this.mSpecialAreaId = 0L;
}
public PIMapOverlayItem(PIMapLocation paramPIMapLocation, String paramString1, String paramString2, int paramInt, long paramLong)
{
this.mLocation = paramPIMapLocation;
this.mTitle = paramString1;
this.mSubTitle = paramString2;
this.mZoneIndex = paramInt;
this.mSpecialAreaId = paramLong;
}
public static void setState(Drawable paramDrawable, int paramInt) {}
Rect getHitBounds()
{
return this.mHitBounds;
}
public PIMapLocation getLocation()
{
return this.mLocation;
}
public Drawable getMarker(int paramInt)
{
return this.mMarker;
}
public Rect getMarkerBounds()
{
return this.mRelativeBounds;
}
public int getPlaceTypeId()
{
return -1;
}
public String getPlaceTypeName()
{
return null;
}
public long getPromoId()
{
return this.mPromoId;
}
public int getPromoType()
{
return this.mPromoType;
}
public int getServiceTypeId()
{
return -1;
}
public String getServiceTypeName()
{
return null;
}
public String getServiceTypeUUID()
{
return null;
}
public long getSpecialAreaId()
{
return this.mSpecialAreaId;
}
public String getSubTitle()
{
return this.mSubTitle;
}
public String getTitle()
{
return this.mTitle;
}
public String getUUID()
{
return null;
}
public int getWormholeTypeId()
{
return -1;
}
public int getZoneIndex()
{
return this.mZoneIndex;
}
public boolean isWormhole()
{
return false;
}
public String routableAddress()
{
return null;
}
void setHitBounds(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
{
if (this.mHitBounds == null) {
this.mHitBounds = new Rect();
}
this.mHitBounds.set(paramInt1, paramInt2, paramInt3, paramInt4);
}
public void setLocation(PIMapLocation paramPIMapLocation)
{
this.mLocation = paramPIMapLocation;
}
public void setMarker(Drawable paramDrawable)
{
this.mMarker = paramDrawable;
if (paramDrawable != null)
{
this.mMarker.setDither(true);
this.mRelativeBounds = paramDrawable.copyBounds();
return;
}
this.mRelativeBounds = null;
}
public void setProjection(PIMapView paramPIMapView)
{
if (this.mLocation != null) {
this.mLocation.translate(paramPIMapView, this.mZoneIndex);
}
}
public void setPromoId(long paramLong)
{
this.mPromoId = paramLong;
}
public void setPromoType(int paramInt)
{
this.mPromoType = paramInt;
}
public void setSubTitle(String paramString)
{
this.mSubTitle = paramString;
}
public void setTitle(String paramString)
{
this.mTitle = paramString;
}
}
/* Location: D:\xinghai\dex2jar\classes-dex2jar.jar
* Qualified Name: com.pointinside.android.api.maps.PIMapOverlayItem
* JD-Core Version: 0.7.0.1
*/ |
package com.example.utsav.sms;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
import android.widget.Toast;
import static android.telephony.SmsMessage.createFromPdu;
/**
* Created by utsav on 29/3/17.
*/
public class SmsReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Bundle bundle=intent.getExtras();
String sendernumber=null;
if(bundle!=null)
{
Object[] pdus=(Object[])bundle.get("pdus"); //incoming message has portable description units
for(int i=0; i< pdus.length ;i++)
{
SmsMessage sms= createFromPdu((byte[])pdus[i],null);
sendernumber = sms.getDisplayOriginatingAddress();
String message=sms.getDisplayMessageBody();
Toast.makeText(context, "From: "+sendernumber+ "Message: "+message,Toast.LENGTH_LONG).show();
}
SmsManager smsmanager=SmsManager.getDefault();
smsmanager.sendTextMessage(sendernumber,null,"Sorry i was busy, will call you back later or never",null,null);
}
}
}
|
package pattern.builder;
import java.util.Calendar;
public class GeradorBoleto {
private BoletoBuilder boletBuilder;
public GeradorBoleto(BoletoBuilder boletBuilder) {
this.boletBuilder = boletBuilder;
}
public Boleto geraBoleto(){
this.boletBuilder.buildSacado("Murilo Nascimento");
this.boletBuilder.buildCedente("K19 Cursos");
this.boletBuilder.buildValor(300.00);
Calendar vencimento = Calendar.getInstance();
vencimento.add(Calendar.DATE,30) ;
this.boletBuilder.buildVencimento(vencimento);
this.boletBuilder.buildNossoNumero(1234);
Boleto boleto = boletBuilder.getBoleto();
return boleto;
}
}
|
package com.example.e_learning;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.firebase.firestore.CollectionReference;
import com.google.firebase.firestore.DocumentReference;
import com.google.firebase.firestore.FirebaseFirestore;
import java.util.HashMap;
import java.util.Map;
public class Course extends AppCompatActivity {
//static final String key_desc = "description";
// static final String key_cont = "content";
Button save;
EditText editText, editText2;
FirebaseFirestore fStore;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_course);
editText = findViewById(R.id.editText);
editText2 = findViewById(R.id.editText2);
save = findViewById(R.id.save);
fStore = FirebaseFirestore.getInstance();
save.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String description = editText.getText().toString();
String content = editText2.getText().toString();
DocumentReference docref = fStore.collection("courses").document();
Map<String, Object> course = new HashMap<>();
course.put("name", description);
course.put("link", content);
//fStore.collection("courses").document().set(course). addOnFailureListener();
docref.set(course).addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void aVoid) {
Toast.makeText(Course.this, "course saved", Toast.LENGTH_SHORT).show();
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Toast.makeText(Course.this, "failed to save" + e.getMessage(), Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
});
}
});
}
} |
package com.example.tejk.opengl_fingerpaint.utils;
import android.content.Context;
import android.opengl.GLES20;
public class ShaderUtils {
public static int loadShader(Context context, int type, int shaderResId) {
return loadFromSource(type, FileUtils.readTextFileFromRawResource(context, shaderResId));
}
private static int loadFromSource(int type, String shaderCode) {
int shader = GLES20.glCreateShader(type);
if (shader != 0) {
GLES20.glShaderSource(shader, shaderCode);
GLES20.glCompileShader(shader);
// Check for shader compilation errors.
int[] compiled = new int[1];
GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
if (compiled[0] == 0) {
GLES20.glDeleteShader(shader);
throw new RuntimeException("Could not compile program: "
+ GLES20.glGetShaderInfoLog(shader) + " | " + shaderCode);
}
}
else
throw new RuntimeException("Could not create shader");
return shader;
}
}
|
package adcar.com.model;
/**
* Created by aditya on 09/02/16.
*/
public class Ad implements Comparable<Ad> {
private Integer id;
private Integer adId;
private String url;
private Integer status;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Integer getAdId() {
return adId;
}
public void setAdId(Integer adId) {
this.adId = adId;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String toString(){
return id + " " + adId + " " + url;
}
@Override
public int compareTo(Ad ad) {
return ad.getAdId();
}
}
|
/*
* 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 DataObjects;
/**
*
* @author Shivam Patel
*/
public class Project_Technology_Object
{
private int Project_ID,Tid;
public Project_Technology_Object() {
}
public int getProject_ID() {
return Project_ID;
}
public void setProject_ID(int Project_ID) {
this.Project_ID = Project_ID;
}
public int getTid() {
return Tid;
}
public void setTid(int Tid) {
this.Tid = Tid;
}
@Override
public String toString() {
return "Project_Technology_Object{" + "Project_ID=" + Project_ID + ", Tid=" + Tid + '}';
}
}
|
package com.redsun.platf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Created with IntelliJ IDEA.
* User: Administrator
* Date: 2012/9/27
* Time: 上午 11:03
* To change this template use File | Settings | File Templates.
*/
public class TestSlf4jLogger {
private static final Logger logger = LoggerFactory.getLogger(TestSlf4jLogger.class);
public static void main(String[] args) {
// logger.info("Hello {}","SLF4J");
logger.info("Hello ");
logger.debug("debug ");
logger.warn("warn ");
}
}
|
package fr.doranco.designpattern.strategy;
public class OuvertureSimpleStrategy extends OuvertureStrategy {
@Override
public void ouvrir() {
// Je tourne le bouchon simple.
}
}
|
package com.zpf.dto;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* Created by LoseMyself
* on 2017/3/13 10:00
*/
// 获取properties内对应节点名称
@ConfigurationProperties(prefix = "girl")
// 能直接Autowire注解需加上这个
@Component
public class girlProperties {
private String cupSize;
private Integer age;
public String getCupSize() {
return cupSize;
}
public girlProperties setCupSize(String cupSize) {
this.cupSize = cupSize;
return this;
}
public Integer getAge() {
return age;
}
public girlProperties setAge(Integer age) {
this.age = age;
return this;
}
}
|
package com.ai.platform.agent.web.services;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.util.Strings;
import org.springframework.stereotype.Service;
import com.ai.platform.agent.entity.Server2ClientMsgMVO;
import com.ai.platform.agent.entity.ShellCommandMVO;
import com.ai.platform.agent.server.entity.AuthChannelInfo;
import com.ai.platform.agent.server.util.ChannelCollectionUtil;
import com.ai.platform.agent.util.AgentServerCommandConstant;
import com.ai.platform.agent.util.ByteArrayUtil;
import com.ai.platform.agent.web.entity.ResultMessageMVO;
import com.ai.platform.agent.web.util.ResultCodeConstants;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
@Service
public class ShellCommandSer {
public static Logger logger = LogManager.getLogger(ShellCommandSer.class);
private AuthChannelInfo getAuthChannelInfo(Server2ClientMsgMVO sendMsg) throws Exception {
ShellCommandMVO commandInfo = sendMsg.getCommandInfo();
String aid = commandInfo.getAid();
String uid = commandInfo.getUid();
String sid = commandInfo.getSid();
String key = aid;
if (Strings.isBlank(aid)) {
throw new Exception("请指定Agent标识");
}
if (Strings.isBlank(uid)) {
throw new Exception("请指定uid标识");
}
if (Strings.isBlank(sid)) {
throw new Exception("请指定sid标识");
}
if (!ChannelCollectionUtil.ctxMap.containsKey(key)) {
throw new Exception("指定的客户端未连接");
}
AuthChannelInfo channel = ChannelCollectionUtil.ctxMap.get(key);
if (!channel.getCtx().channel().isActive()) {
throw new Exception("指定的客户端未激活");
}
return channel;
}
/***
* 初始化会话
*
* @param sendMsg
* @return
* @throws Exception
*/
public String initCommandSession(Server2ClientMsgMVO sendMsg) throws Exception {
AuthChannelInfo channel = getAuthChannelInfo(sendMsg);
ShellCommandMVO commandInfo = sendMsg.getCommandInfo();
String content = JSONObject.toJSONString(commandInfo.getHostInfo());
logger.info("服务端ssh到客户端，信息为：{}", commandInfo.getHostInfo());
byte[] openCommandArray = ByteArrayUtil.mergeByteArray(AgentServerCommandConstant.PACKAGE_TYPE_SSH_OPEN,
commandInfo.getUid().getBytes(), commandInfo.getSid().getBytes(), content.getBytes());
channel.getCtx().channel().writeAndFlush(openCommandArray);
ResultMessageMVO result = new ResultMessageMVO(ResultCodeConstants.OK, ResultCodeConstants.OK_MSG);
return JSON.toJSONString(result);
}
/***
* 执行命令
*
* @param sendMsg
* @return
* @throws Exception
*/
public String execCommand(Server2ClientMsgMVO sendMsg) throws Exception {
AuthChannelInfo channel = getAuthChannelInfo(sendMsg);
ShellCommandMVO commandInfo = sendMsg.getCommandInfo();
byte[] execCommandArray = ByteArrayUtil.mergeByteArray(AgentServerCommandConstant.PACKAGE_TYPE_EXEC_COMMAND,
commandInfo.getUid().getBytes(), commandInfo.getSid().getBytes(),
JSON.toJSONString(sendMsg).getBytes());
channel.getCtx().channel().writeAndFlush(execCommandArray);
ResultMessageMVO result = new ResultMessageMVO(ResultCodeConstants.OK, ResultCodeConstants.OK_MSG);
return JSON.toJSONString(result);
}
/***
* 销毁会话
*
* @param sendMsg
* @return
* @throws Exception
*/
public String destroyCommand(Server2ClientMsgMVO sendMsg) throws Exception {
AuthChannelInfo channel = getAuthChannelInfo(sendMsg);
ShellCommandMVO commandInfo = sendMsg.getCommandInfo();
String content = "close session";
byte[] closeCommandArray = ByteArrayUtil.mergeByteArray(AgentServerCommandConstant.PACKAGE_TYPE_SSH_CLOSE,
commandInfo.getUid().getBytes(), commandInfo.getSid().getBytes(), content.getBytes());
channel.getCtx().channel().writeAndFlush(closeCommandArray);
ResultMessageMVO result = new ResultMessageMVO(ResultCodeConstants.OK, ResultCodeConstants.OK_MSG);
return JSON.toJSONString(result);
}
}
|
package com.lesports.albatross.json;
//import com.f1llib.utils.LogUtil;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* Created by litzuhsien on 4/2/15.
*/
public class SimpleDateAdapter implements JsonDeserializer<Date> {
private static final String DefaultDateFormatPattern = "yyyyMMddHHmmss";
@Override
public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
String jsonField = json.getAsString();
assert typeOfT.getClass().isAssignableFrom(Date.class);
String s = jsonField;
if (s.isEmpty() && s.trim().isEmpty())
return null;
else {
SimpleDateFormat dateFormat = new SimpleDateFormat(DefaultDateFormatPattern);
try {
Date date = dateFormat.parse(jsonField);
// LogUtil.i("SimpleDateAdapter", dateFormat.format(date));
return date;
} catch (ParseException ex) {
return null;
}
}
}
}
|
package net.itcast.course.regex.basic.lesson2;
public class CharacterClassShorthand {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String digitChar = "\\d";
String noDigitChar = "\\D";
String wordChar = "\\w";
String noWordChar = "\\W";
String spaceChar = "\\s";
String noSpaceShar = "\\S";
String[] strs = new String[] { "0", "3", "8", "9", "a", "z", "E", "G",
" ", "\t", "\r" };
for (String s : strs) {
if (regexMatch(s, digitChar)) {
System.out.println("\"" + digitChar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + digitChar + "\" can not match \"" + s
+ "\"");
}
}
System.out.println("");
for (String s : strs) {
if (regexMatch(s, noDigitChar)) {
System.out.println("\"" + noDigitChar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + noDigitChar + "\" can not match \""
+ s + "\"");
}
}
System.out.println("");
for (String s : strs) {
if (regexMatch(s, wordChar)) {
System.out.println("\"" + wordChar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + wordChar + "\" can not match \"" + s
+ "\"");
}
}
System.out.println("");
for (String s : strs) {
if (regexMatch(s, noWordChar)) {
System.out.println("\"" + noWordChar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + noWordChar + "\" can not match \""
+ s + "\"");
}
}
System.out.println("");
for (String s : strs) {
if (regexMatch(s, spaceChar)) {
System.out.println("\"" + spaceChar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + spaceChar + "\" can not match \"" + s
+ "\"");
}
}
System.out.println("");
for (String s : strs) {
if (regexMatch(s, noSpaceShar)) {
System.out.println("\"" + noSpaceShar + "\" can match \"" + s
+ "\"");
} else {
System.out.println("\"" + noSpaceShar + "\" can not match \""
+ s + "\"");
}
}
}
public static boolean regexMatch(String s, String regex) {
return s.matches(regex);
}
}
|
/********************************
* DragonMail Email Client *
* (C) 2013 David Gardner *
* *
* Source released under the *
* GNU General Public License *
* *
********************************/
package client;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.text.DateFormat;
import java.util.*;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.mail.*;
import javax.mail.Flags.Flag;
import javax.mail.internet.*;
import javax.mail.search.FlagTerm;
public class Main {
String version = "Beta v1.1";
File settingsFile = new File(".mailsettings");
String username, password, host, port;
Properties props = new Properties();
Session session;
Authenticator auth;
static JTextArea console = new JTextArea(5, 50); //Unimplemented
DefaultListModel listModel = new DefaultListModel();
ArrayList<DMessage> messages = new ArrayList<DMessage>();
JList messageList = new JList();
public Main() {
loadGUI();
if(!loadSettings()) {
loadSettingsGUI();
return;
}
init();
}
public void init() {
auth = new Authenticator() {
private PasswordAuthentication pa = new PasswordAuthentication(username, password);
public PasswordAuthentication getPasswordAuthentication() {
return pa;
}
};
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", port);
props.put("mail.smtp.ssl.enable", true);
props.put("mail.smtp.auth", true);
props.put("mail.store.protocol", "imaps");
session = Session.getInstance(props, auth);
addToList(checkMail());
}
public boolean loadSettings() {
if(!settingsFile.exists()) return false;
try {
Scanner scanner = new Scanner(settingsFile);
username = scanner.nextLine();
password = scanner.nextLine();
host = scanner.nextLine();
port = scanner.nextLine();
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
printMessage(e.getMessage());
}
return true;
}
public void writeSettings() {
printMessage("host: " + host + ":" + port);
try {
PrintWriter writer = new PrintWriter(settingsFile);
writer.write(username + "\n");
writer.write(password + "\n");
writer.write(host + "\n");
writer.write(port + "\n");
writer.flush();
writer.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void printMessage(String message) {
console.setText(message);
System.out.println(message);
}
public void loadGUI() {
JFrame frame = new JFrame("DragonMail " + version);
frame.setSize(1000, 600);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setLayout(new BorderLayout());
//frame.add(console, BorderLayout.SOUTH);
JSplitPane messagePane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
JPanel messagePanel = new JPanel();
messagePanel.setLayout(new BorderLayout());
final JTextArea messageArea = new JTextArea(10, 10);
messagePanel.add(messageArea, BorderLayout.CENTER);
messagePane.setRightComponent(messagePanel);
messageList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
messageList.setLayoutOrientation(JList.VERTICAL);
messageList.setVisibleRowCount(5);
messagePane.setLeftComponent(new JScrollPane(messageList));
JPanel infoPanel = new JPanel();
infoPanel.setLayout(new GridBagLayout());
GridBagConstraints label = new GridBagConstraints();
GridBagConstraints field = new GridBagConstraints();
label.gridx = 0;
label.gridy = 0;
field.gridx = 1;
field.gridy = 0;
infoPanel.add(new JLabel("To"), label);
final JTextField toField = new JTextField(30);
toField.setEditable(false);
infoPanel.add(toField, field);
label.gridy = 1;
field.gridy = 1;
infoPanel.add(new JLabel("From "), label);
final JTextField fromField = new JTextField(30);
fromField.setEditable(false);
infoPanel.add(fromField, field);
label.gridx = 2;
label.gridy = 0;
field.gridx = 3;
field.gridy = 0;
infoPanel.add(new JLabel("CC"), label);
final JTextField ccField = new JTextField(30);
ccField.setEditable(false);
infoPanel.add(ccField, field);
label.gridy = 1;
field.gridy = 1;
infoPanel.add(new JLabel("BCC"), label);
final JTextField bccField = new JTextField(30);
bccField.setEditable(false);
infoPanel.add(bccField, field);
label.gridy = 2;
field.gridy = 2;
label.gridx = 0;
field.gridx = 1;
field.gridwidth = 4;
infoPanel.add(new JLabel("Subject "), label);
final JTextField subjectField = new JTextField(63);
subjectField.setEditable(false);
infoPanel.add(subjectField, field);
messagePanel.add(infoPanel, BorderLayout.NORTH);
field.gridx = 4;
field.gridy = 0;
final JButton sendButton = new JButton("Send");
sendButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
DMessage m = new DMessage();
StringTokenizer t = new StringTokenizer(toField.getText(), "; ");
String[] array = new String[t.countTokens()];
if(array.length == 0) {
printMessage("Message must have at least one recipient");
return;
}
for(int i=0; i<array.length; i++) {
array[i] = t.nextToken();
}
m.setTo(array);
m.setFrom(username);
t = new StringTokenizer(ccField.getText(), "; ");
array = new String[t.countTokens()];
for(int i=0; i<array.length; i++) {
array[i] = t.nextToken();
}
m.setcc(array);
t = new StringTokenizer(bccField.getText(), "; ");
array = new String[t.countTokens()];
for(int i=0; i<array.length; i++) {
array[i] = t.nextToken();
}
m.setbcc(array);
m.setSubject(subjectField.getText());
m.setContent(messageArea.getText());
sendMail(m);
}
});
sendButton.setEnabled(false);
JButton checkButton = new JButton("Check Mail");
checkButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
messageArea.setEditable(false);
addToList(checkMail());
sendButton.setEnabled(false);
fromField.setEnabled(true);
toField.setEditable(false);
ccField.setEditable(false);
bccField.setEditable(false);
subjectField.setEditable(false);
}
});
infoPanel.add(checkButton, field);
JButton composeButton = new JButton("Compose");
composeButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
sendButton.setEnabled(true);
fromField.setEnabled(false);
toField.setEditable(true);
ccField.setEditable(true);
bccField.setEditable(true);
subjectField.setEditable(true);
toField.setText("");
fromField.setText("");
ccField.setText("");
bccField.setText("");
subjectField.setText("");
messageArea.setText("");
messageArea.setEditable(true);
}
});
field.gridy = 1;
infoPanel.add(composeButton, field);
field.gridy = 2;
infoPanel.add(sendButton, field);
messagePanel.add(infoPanel, BorderLayout.NORTH);
messageList.addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
toField.setEditable(false);
fromField.setEditable(false);
fromField.setEnabled(true);
ccField.setEditable(false);
bccField.setEditable(false);
subjectField.setEditable(false);
messageArea.setEditable(false);
DMessage m = messages.get(messageList.getSelectedIndex());
toField.setText(m.getToString());
fromField.setText(m.getFrom());
ccField.setText(m.getccString());
bccField.setText(m.getbccString());
subjectField.setText(m.getSubject());
messageArea.setText(m.getContent());
}
});
frame.add(messagePane, BorderLayout.CENTER);
frame.setVisible(true);
}
public DMessage[] checkMail() {
printMessage("Checking Mail...");
try {
Store store = session.getStore("imaps");
store.connect("imap.gmail.com", username, password);
Folder inbox = store.getFolder("Inbox");
printMessage(inbox.getUnreadMessageCount() + " unread message(s)");
inbox.open(Folder.READ_WRITE);
Message messages[] = inbox.search(new FlagTerm(new Flags(Flag.SEEN), false));
FetchProfile fp = new FetchProfile();
fp.add(FetchProfile.Item.ENVELOPE);
fp.add(FetchProfile.Item.CONTENT_INFO);
inbox.fetch(messages, fp);
inbox.setFlags(messages, new Flags(Flags.Flag.SEEN), true);
DMessage[] dm = new DMessage[messages.length];
for(int i=0; i<messages.length; i++) {
dm[i] = new DMessage(messages[i]);
}
return dm;
} catch (MessagingException e) {
printMessage(e.getMessage());
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public void addToList(DMessage[] m) {
for(int i=0; i<m.length; i++) {
messages.add(m[i]);
listModel.addElement(m[i].getFrom() + " - " + m[i].getSubject()
+ " " + DateFormat.getInstance().format(m[i].getDate()));
System.out.println("Message " + i + ": " + m[i].getFrom() + " - "
+ m[i].getSubject() + "\t" + DateFormat.getInstance().format(m[i].getDate()));
}
messageList.setModel(listModel);
}
public void sendMail(DMessage message) {
try {
MimeMessage m = message.getMimeMessage(session);
printMessage("Sending message titled \"" + message.getSubject() + "\"");
Transport.send(m);
printMessage("Done");
} catch(MessagingException e) {
e.printStackTrace();
printMessage("Message send failure");
}
}
public void loadSettingsGUI() {
final JFrame frame = new JFrame("DragonMail " + version + " - Settings");
frame.setSize(600, 600);
frame.setLocationRelativeTo(null);
frame.setLayout(new BorderLayout());
JPanel main = new JPanel();
main.add(new JLabel("Username:"));
final JTextField uField = new JTextField(20);
main.add(uField);
main.add(new JLabel("Password"));
final JPasswordField pField = new JPasswordField(20);
main.add(pField);
main.add(new JLabel("Host"));
String[] hosts = {"Gmail"};
final JComboBox hostList = new JComboBox(hosts);
hostList.setEditable(false);
main.add(hostList);
JButton saveButton = new JButton("Save Settings");
saveButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
username = uField.getText();
password = new String(pField.getPassword());
if(hostList.getSelectedItem().toString().equals("Gmail")) {
host = "smtp.gmail.com";
port = "465";
}
writeSettings();
frame.setVisible(false);
init();
}
});
main.add(saveButton);
frame.add(main, BorderLayout.CENTER);
frame.setVisible(true);
}
public static void main(String[] args) {
new Main();
}
}
|
package com.penglai.haima.ui.index;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.chad.library.adapter.base.BaseQuickAdapter;
import com.lzy.okgo.OkGo;
import com.penglai.haima.R;
import com.penglai.haima.adapter.ShopAdapter;
import com.penglai.haima.base.BaseFragmentV4;
import com.penglai.haima.base.Constants;
import com.penglai.haima.bean.ShopDataBean;
import com.penglai.haima.callback.JsonFragmentCallback;
import com.penglai.haima.okgomodel.CommonReturnData;
import com.penglai.haima.ui.shop.ShopDetailsActivity;
import com.penglai.haima.utils.PhoneUtil;
import com.penglai.haima.utils.ViewHWRateUtil;
import com.penglai.haima.widget.GlideRoundImageLoader;
import com.scwang.smart.refresh.layout.SmartRefreshLayout;
import com.scwang.smart.refresh.layout.api.RefreshLayout;
import com.scwang.smart.refresh.layout.listener.OnRefreshListener;
import com.youth.banner.Banner;
import java.util.ArrayList;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import static com.penglai.haima.base.BaseActivity.PULL_DOWN_TIME;
/**
* Created by on 2019/11/8.
* 文件说明：商家列表展示
*/
public class ShopIndexFragment extends BaseFragmentV4 implements OnRefreshListener {
private int state = -1;
private SmartRefreshLayout smartRefreshLayout;
private RecyclerView recyclerView;
private View view_top;
private View emptyView;
private Banner banner;
private ShopAdapter shopAdapter;
List<ShopDataBean> shopDataBeans = new ArrayList<>();
@Override
protected View initView(LayoutInflater inflater) {
state = getArguments().getInt("state");
View view = inflater.inflate(R.layout.fragment_shop_index, null);
initView(view);
initViewData();
return view;
}
public static ShopIndexFragment getInstance(int state) {
ShopIndexFragment fragment = new ShopIndexFragment();
Bundle bundle = new Bundle();
bundle.putInt("state", state);
fragment.setArguments(bundle);
return fragment;
}
@Override
protected void initViewData() {
ViewGroup.LayoutParams params = view_top.getLayoutParams();
//获取当前控件的布局对象
params.height = PhoneUtil.getStatusHeight(getActivity()) + 5;//设置当前控件布局的高度
view_top.setLayoutParams(params);
ViewHWRateUtil.setHeightWidthRate(mContext, banner, 2.13);//640/300
shopAdapter = new ShopAdapter(shopDataBeans);
recyclerView.setLayoutManager(new LinearLayoutManager(mContext));
recyclerView.setAdapter(shopAdapter);
smartRefreshLayout.setEnableLoadMore(false);
smartRefreshLayout.setEnableRefresh(false);
smartRefreshLayout.setOnRefreshListener(this);
List<String> images = new ArrayList<>();
images.add(Constants.URL_FOR_PIC + "banner/banner1.png");
images.add(Constants.URL_FOR_PIC + "banner/banner2.png");
images.add(Constants.URL_FOR_PIC + "banner/banner3.png");
images.add(Constants.URL_FOR_PIC + "banner/banner4.png");
images.add(Constants.URL_FOR_PIC + "banner/banner5.png");
banner.setImageLoader(new GlideRoundImageLoader());
banner.setImages(images);
banner.start();
shopAdapter.setOnItemClickListener(new BaseQuickAdapter.OnItemClickListener() {
@Override
public void onItemClick(BaseQuickAdapter adapter, View view, int position) {
Intent intent = new Intent(mContext, ShopDetailsActivity.class);
Bundle bundle = new Bundle();
bundle.putSerializable("shopDataBean", shopDataBeans.get(position));
intent.putExtras(bundle);
startActivity(intent);
}
});
}
@Override
public void initData() {
getShopList();
}
@Override
public void reLoadData() {
super.reLoadData();
getShopList();
}
private void initView(View view) {
smartRefreshLayout = (SmartRefreshLayout) view.findViewById(R.id.smartRefreshLayout);
recyclerView = (RecyclerView) view.findViewById(R.id.recyclerView);
banner = view.findViewById(R.id.banner);
view_top = view.findViewById(R.id.view);
emptyView = getEmptyView();
}
@Override
public void onRefresh(@NonNull final RefreshLayout refreshLayout) {
refreshLayout.getLayout().postDelayed(new Runnable() {
@Override
public void run() {
getShopList();
refreshLayout.finishRefresh();
refreshLayout.setNoMoreData(false);
}
}, PULL_DOWN_TIME);
}
/**
* 获取商家列表
*/
private void getShopList() {
// if (!SharepreferenceUtil.getString(Constants.CURRENT_CITY).contains("无锡")) {
// mLoadingLayout.setStatus(LoadingLayout.Error);
// mLoadingLayout.setErrorText("当前城市暂未开放,\n敬请期待")
// .setErrorImageVisible(false)
// .setErrorTextSize(18)
// .setReloadButtonBackgroundResource(R.color.transparent)
// .setReloadButtonText("");
// return;
// }
OkGo.<CommonReturnData<List<ShopDataBean>>>get(Constants.BASE_URL + "provider/getProviderInfo")
.execute(new JsonFragmentCallback<CommonReturnData<List<ShopDataBean>>>(this, true, true) {
@Override
public void onSuccess(CommonReturnData<List<ShopDataBean>> commonReturnData) {
shopDataBeans.clear();
shopDataBeans.addAll(commonReturnData.getData());
shopAdapter.notifyDataSetChanged();
if (shopDataBeans.isEmpty()) {
shopAdapter.setEmptyView(emptyView);
}
}
});
}
}
|
package com.citibank.ods.modules.product.player.form;
//
//©2002-2007 Accenture. All rights reserved.
//
/**
* [Class description]
*
* @see package com.citibank.ods.modules.product.player.form;
* @version 1.0
* @author angelica.almeida,27/05/2007
*
* <PRE>
*
* <U>Updated by: </U> <U>Description: </U>
*
* </PRE>
*/
public interface PlayerSearchable
{
/**
* @return SelectedPlyrCnpjNbr. Retorna o valor selecionado no grid.
*/
public String getSelectedPlyrCnpjNbrSrc();
/**
* @param plyrCnpjNbr. Seta o cnpj do player.
*/
public void setSelectedPlyrCnpjNbrSrc( String plyrCnpjNbr_ );
public String getPlyrCnpjNbrSrc();
public void setPlyrCnpjNbrSrc( String plyrCnpjNbrSrc_ );
} |
package com.thinkgem.jeesite.modules.sys.web;
import com.thinkgem.jeesite.common.config.Global;
import java.util.List;
import java.util.ArrayList;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.google.common.collect.Lists;
import com.thinkgem.jeesite.common.persistence.Page;
import com.thinkgem.jeesite.common.web.BaseController;
import com.thinkgem.jeesite.common.utils.DateUtils;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.common.utils.excel.ExportExcel;
import com.thinkgem.jeesite.common.utils.excel.ImportExcel;
import com.thinkgem.jeesite.modules.sys.entity.GuestAccess;
import com.thinkgem.jeesite.modules.sys.service.GuestAccessService;
/**
* 访问信息记录模块Controller
* @author gyl
* @version 2019-03-11
*/
@Controller
@RequestMapping(value = "${adminPath}/sys/guestAccess")
public class GuestAccessController extends BaseController {
private static final String FUNCTION_NAME_SIMPLE = "访问日志功能";
@Autowired
private GuestAccessService guestAccessService;
@ModelAttribute
public GuestAccess get(@RequestParam(required=false) String id) {
GuestAccess entity = null;
if (StringUtils.isNotBlank(id)){
entity = guestAccessService.get(id);
}
if (entity == null){
entity = new GuestAccess();
}
return entity;
}
@RequiresPermissions("sys:guestAccess:view")
@RequestMapping(value = {"list", ""})
public String list(GuestAccess guestAccess, HttpServletRequest request, HttpServletResponse response, Model model) {
Page<GuestAccess> page = guestAccessService.findPage(new Page<GuestAccess>(request, response), guestAccess);
model.addAttribute("page", page);
model.addAttribute("ename", "guestAccess");
setBase64EncodedQueryStringToEntity(request, guestAccess);
return "modules/sys/guestAccess/guestAccessList";
}
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "form")
public String form(GuestAccess guestAccess, Model model) {
model.addAttribute("guestAccess", guestAccess);
model.addAttribute("ename", "guestAccess");
return "modules/sys/guestAccess/guestAccessForm";
}
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "save")
public String save(GuestAccess guestAccess, Model model, RedirectAttributes redirectAttributes) {
if (!beanValidator(model, guestAccess)){
return form(guestAccess, model);
}
addMessage(redirectAttributes, StringUtils.isBlank(guestAccess.getId()) ? "保存"+FUNCTION_NAME_SIMPLE+"成功" : "修改"+FUNCTION_NAME_SIMPLE+"成功");
guestAccessService.save(guestAccess);
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "disable")
public String disable(GuestAccess guestAccess, RedirectAttributes redirectAttributes) {
guestAccessService.disable(guestAccess);
addMessage(redirectAttributes, "禁用"+FUNCTION_NAME_SIMPLE+"成功");
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "delete")
public String delete(GuestAccess guestAccess, RedirectAttributes redirectAttributes) {
guestAccessService.delete(guestAccess);
addMessage(redirectAttributes, "删除"+FUNCTION_NAME_SIMPLE+"成功");
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "deleteBatch")
public String deleteBatch(GuestAccess guestAccess, RedirectAttributes redirectAttributes) {
guestAccessService.deleteByIds(guestAccess);
addMessage(redirectAttributes, "批量删除"+FUNCTION_NAME_SIMPLE+"成功");
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
/**
* 导出数据
*/
@RequiresPermissions("sys:guestAccess:view")
@RequestMapping(value = "export", method = RequestMethod.POST)
public String exportFile(GuestAccess guestAccess, HttpServletRequest request,
HttpServletResponse response, RedirectAttributes redirectAttributes) {
try {
String fileName = FUNCTION_NAME_SIMPLE + DateUtils.getDate("yyyyMMddHHmmss") + ".xlsx";
guestAccess.setPage(new Page<GuestAccess>(request, response, -1));
new ExportExcel(FUNCTION_NAME_SIMPLE, GuestAccess.class).setDataList(guestAccessService.findList(guestAccess)).write(response, fileName).dispose();
return null;
} catch (Exception e) {
addMessage(redirectAttributes, "导出" + FUNCTION_NAME_SIMPLE + "失败！失败信息：" + e.getMessage());
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
}
/**
* 下载导入数据模板
*/
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "import/template")
public String importFileTemplate(GuestAccess guestAccess, HttpServletResponse response, RedirectAttributes redirectAttributes) {
try {
String fileName = FUNCTION_NAME_SIMPLE + "导入模板.xlsx";
List<GuestAccess> list = guestAccessService.findPage(new Page<GuestAccess>(1, 5), new GuestAccess()).getList();
if (list == null) {
list = Lists.newArrayList();
}
if (list.size() < 1) {
list.add(new GuestAccess());
}
new ExportExcel(FUNCTION_NAME_SIMPLE, GuestAccess.class).setDataList(list).write(response, fileName).dispose();
return null;
} catch (Exception e) {
addMessage(redirectAttributes, "导入模板下载失败！失败信息：" + e.getMessage());
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
}
/**
* 导入数据<br>
*/
@RequiresPermissions("sys:guestAccess:edit")
@RequestMapping(value = "import", method = RequestMethod.POST)
public String importFile(GuestAccess guestAccess, MultipartFile file, RedirectAttributes redirectAttributes) {
if(Global.isDemoMode()){
addMessage(redirectAttributes, "演示模式，不允许操作！");
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
try {
long beginTime = System.currentTimeMillis();//1、开始时间
StringBuilder failureMsg = new StringBuilder();
ImportExcel ei = new ImportExcel(file, 1, 0);
List<GuestAccess> list = ei.getDataList(GuestAccess.class);
List<GuestAccess> insertList=new ArrayList<GuestAccess>();
List<GuestAccess> subList=new ArrayList<GuestAccess>();
int batchinsertSize=500;
int batchinsertCount=list.size()/batchinsertSize+(list.size()%batchinsertSize==0?0:1);
int addNum=0;
int updateNum=0;
int toIndex=0;
for(int i=0;i<batchinsertCount;i++)
{
insertList=new ArrayList<GuestAccess>();
toIndex=(i+1)*batchinsertSize;
if(toIndex>list.size())
toIndex=list.size();
subList=list.subList(i*batchinsertSize, toIndex);
for(GuestAccess zsJh : subList)
{
zsJh.preInsert();
insertList.add(zsJh);
}
if(insertList!=null&&insertList.size()>0)
{
// System.out.println("insertList size is :"+insertList.size());
guestAccessService.batchInsertUpdate(insertList);
addNum+=insertList.size();
}
}
long endTime = System.currentTimeMillis(); //2、结束时间
addMessage(redirectAttributes, "执行时间"+DateUtils.formatDateTime(endTime - beginTime)+",导入 "+addNum+"条"+FUNCTION_NAME_SIMPLE+"信息,"+failureMsg);
// System.out.println("执行时间："+DateUtils.formatDateTime(endTime - beginTime));
} catch (Exception e) {
addMessage(redirectAttributes, "导入"+FUNCTION_NAME_SIMPLE+"信息失败！失败信息："+e.getMessage());
}
return "redirect:"+adminPath+"/sys/guestAccess/?repage&" + StringUtils.trimToEmpty(getBase64DecodedQueryStringFromEntity(guestAccess));
}
} |
/******************************************************************************
* __ *
* <-----/@@\-----> *
* <-< < \\// > >-> *
* <-<-\ __ /->-> *
* Data / \ Crow *
* ^ ^ *
* info@datacrow.net *
* *
* This file is part of Data Crow. *
* Data Crow is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public *
* License as published by the Free Software Foundation; either *
* version 3 of the License, or any later version. *
* *
* Data Crow is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
* See the GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program. If not, see http://www.gnu.org/licenses *
* *
******************************************************************************/
package net.datacrow.settings.definitions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.StringTokenizer;
public class QuickViewFieldDefinitions implements IDefinitions {
private Collection<QuickViewFieldDefinition> definitions = new ArrayList<QuickViewFieldDefinition>();
private final int module;
public QuickViewFieldDefinitions(int module) {
this.module = module;
}
@Override
public void add(Collection<Definition> c) {
for (Definition definition : c)
add(definition);
}
@Override
public void add(Definition definition) {
if (!exists(definition))
definitions.add((QuickViewFieldDefinition) definition);
}
@Override
public void clear() {
definitions.clear();
}
public Collection<QuickViewFieldDefinition> getQuickViewDefinitions() {
return definitions;
}
@Override
public Collection<QuickViewFieldDefinition> getDefinitions() {
return definitions;
}
@Override
public int getSize() {
return definitions.size();
}
private void removeDefinition(int field) {
QuickViewFieldDefinition definition = null;
for (QuickViewFieldDefinition d : definitions) {
if (d.getField() == field) {
definition = d;
break;
}
}
if (definition != null)
definitions.remove(definition);
}
@Override
public boolean exists(Definition definition) {
return definitions.contains(definition);
}
@Override
public void add(String s) {
StringTokenizer st = new StringTokenizer(s, "/&/");
int field = Integer.parseInt((String) st.nextElement());
boolean enabled = Boolean.valueOf((String) st.nextElement()).booleanValue();
String direction = (String) st.nextElement();
int maxLength = 0;
if (st.hasMoreElements())
maxLength = Integer.parseInt((String) st.nextElement());
removeDefinition(field);
add(new QuickViewFieldDefinition(field, enabled, direction, maxLength));
}
}
|
package com.ut.database.entity;
import android.arch.persistence.room.Entity;
import android.arch.persistence.room.PrimaryKey;
@Entity
public class Lock {
/**
* modelNum :
* electric : 100
* latitude :
* blueKey :
* type : 1
* mac : 33-33-22-A1-B0-66
* adminPwd :
* createTime : 1544596624000
* name : LS测试锁
* lockVersion :
* id : 12
* userType : 1
* initTime : 1544596511000
* status : 0
* longitude :
*/
private String modelNum;
private int electric;
private String latitude;
private String blueKey;
private int type;
private String mac;
private String adminPwd;
private long createTime;
private String name;
private String lockVersion;
@PrimaryKey
private int id;
private int userType;
private long initTime;
private String status;
private String longitude;
public String getModelNum() {
return modelNum;
}
public void setModelNum(String modelNum) {
this.modelNum = modelNum;
}
public int getElectric() {
return electric;
}
public void setElectric(int electric) {
this.electric = electric;
}
public String getLatitude() {
return latitude;
}
public void setLatitude(String latitude) {
this.latitude = latitude;
}
public String getBlueKey() {
return blueKey;
}
public void setBlueKey(String blueKey) {
this.blueKey = blueKey;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getMac() {
return mac;
}
public void setMac(String mac) {
this.mac = mac;
}
public String getAdminPwd() {
return adminPwd;
}
public void setAdminPwd(String adminPwd) {
this.adminPwd = adminPwd;
}
public long getCreateTime() {
return createTime;
}
public void setCreateTime(long createTime) {
this.createTime = createTime;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLockVersion() {
return lockVersion;
}
public void setLockVersion(String lockVersion) {
this.lockVersion = lockVersion;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getUserType() {
return userType;
}
public void setUserType(int userType) {
this.userType = userType;
}
public long getInitTime() {
return initTime;
}
public void setInitTime(long initTime) {
this.initTime = initTime;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getLongitude() {
return longitude;
}
public void setLongitude(String longitude) {
this.longitude = longitude;
}
}
|
package com.evan.demo.yizhu.keting_fragment;
import android.content.Context;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import com.evan.demo.yizhu.R;
public class keting_dianshi extends Fragment {
private View rootView;
private ImageButton dianshiButton;
private int flag = 0;
@Override
public void onAttach(Context context) {
super.onAttach(context);
}
@Override
public View onCreateView(@Nullable LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
rootView = inflater.inflate(R.layout.fragment_keting_dianshi, container, false);
initUi();
return rootView;
}
private void initUi() {
//这里写加载布局的代码
dianshiButton = (ImageButton)rootView.findViewById(R.id.dianshiButton_keting);
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
//这里写逻辑代码
if(flag == 0 ){
dianshiButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.button_circle_notselect));
dianshiButton.setImageDrawable(getResources().getDrawable(R.drawable.button_off));
}
else {
dianshiButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.button_circle_isselect));
dianshiButton.setImageDrawable(getResources().getDrawable(R.drawable.button_on));
}
dianshiButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if(flag == 0 ){
dianshiButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.button_circle_isselect));
dianshiButton.setImageDrawable(getResources().getDrawable(R.drawable.button_on));
flag = 1;
}
else {
dianshiButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.button_circle_notselect));
dianshiButton.setImageDrawable(getResources().getDrawable(R.drawable.button_off));
flag = 0;
}
}
});
}
}
|
package com.needii.dashboard.model;
import java.io.Serializable;
import javax.persistence.*;
/**
* The persistent class for the medias database table.
*
*/
@Entity
@Table(name="medias")
@NamedQuery(name="Media.findAll", query="SELECT m FROM Media m")
public class Media implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private int id;
@Column(name="image_url")
private String imageUrl;
private int type;
//bi-directional many-to-one association to Customer
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="user_id")
private Customer customer;
//bi-directional many-to-one association to Product
@ManyToOne(fetch=FetchType.LAZY)
private Product product;
public Media() {
}
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public String getImageUrl() {
return this.imageUrl;
}
public void setImageUrl(String imageUrl) {
this.imageUrl = imageUrl;
}
public int getType() {
return this.type;
}
public void setType(int type) {
this.type = type;
}
public Customer getCustomer() {
return this.customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
public Product getProduct() {
return this.product;
}
public void setProduct(Product product) {
this.product = product;
}
} |
package com.codigo.smartstore.sdk.core.operate;
import static com.codigo.smartstore.sdk.core.opearte.SetOperator.union;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Set;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import com.codigo.smartstore.sdk.core.opearte.IPalindromValidation;
import com.codigo.smartstore.sdk.core.opearte.RecursivePalindrom;
@DisplayName(value = "Testy wyrażenia typu palindrom")
class PalindromTests {
@ParameterizedTest
@ValueSource(
strings = {
"Kobyła ma mały bok", "Akta generała ma mała renegatka", "Ile Romanowi dała za ład Iwona moreli",
"Łapał za kran a kanarka złapał", "Zakopane na pokaz", "Żartem dano nadmetraż", "A kilku tu klika", "radar",
"rotor", "sedes", "senes", "sos", "towot", "jeż largo gra lżej", "udoi miś i miodu" })
void testPalindrom(final String input) {
final var palindromText = input;
final var validator = new RecursivePalindrom();
final var isPalindrom = validator.validate(palindromText);
assertThat(true, equalTo(isPalindrom));
}
@Test
void testPalindrom_IsEmpty() {
final var palindromText = "";
final var validator = new IPalindromValidation() {};
final var isPalindrom = validator.validate(palindromText);
assertThat(false, equalTo(isPalindrom));
}
@Test
void testPalindrom_IsNotValid() {
final var palindromText = "caz";
final var validator = new IPalindromValidation() {};
final var isPalindrom = validator.validate(palindromText);
assertThat(false, equalTo(isPalindrom));
}
@Test
void testPalindrom_IsNullExceptionValid() {
final var validator = new IPalindromValidation() {};
assertThrows(NullPointerException.class,
(
) -> {
validator.validate(null);
}
);
final Set<Integer> integers = Set.of(1, 3, 5);
// final Set<Integer> integers1 = Set.of(1, 3, 5);
final Set<Double> doubles = Set.of(2.1, 4.1, 6.1);
final Set<Byte> bytes = Set.of((byte) -2, (byte) -4, (byte) -6, (byte) 5);
Set<Number> numbers = union(integers, doubles);
numbers = union(numbers, bytes);
// numbers = union(numbers, integers1);
numbers.stream()
.map(item -> {
if (item instanceof Integer)
return (double) (int) item;
else if (item instanceof Double)
return (double) item;
else if (item instanceof Byte)
return (double) (byte) item;
else
return 0.0;
})
.sorted()
.forEach(System.out::println);
}
}
|
package org.apache.hadoop.hdfs.server.namenode.persistance;
import java.io.IOException;
import java.util.LinkedList;
import org.apache.hadoop.hdfs.server.namenode.FSNamesystem;
import org.apache.hadoop.hdfs.server.namenode.INode;
import org.apache.hadoop.hdfs.server.namenode.Namesystem;
import org.apache.hadoop.hdfs.server.namenode.persistance.context.TransactionContextException;
import org.apache.hadoop.hdfs.server.namenode.persistance.storage.StorageException;
import org.apache.log4j.NDC;
/**
*
* @author kamal hakimzadeh<kamal@sics.se>
*/
public abstract class TransactionalRequestHandler extends RequestHandler {
public TransactionalRequestHandler(OperationType opType) {
super(opType);
}
@Override
protected Object run(boolean writeLock, boolean readLock, Namesystem namesystem) throws IOException {
boolean systemLevelLock = FSNamesystem.systemLevelLock();
boolean rowLevelLock = FSNamesystem.rowLevelLock();
if (systemLevelLock) {
if (writeLock) {
namesystem.writeLock();
}
if (readLock) {
namesystem.readLock();
}
}
boolean retry = true;
boolean rollback = false;
int tryCount = 0;
IOException exception = null;
long txStartTime = 0;
try {
while (retry && tryCount < RETRY_COUNT) {
retry = true;
rollback = false;
tryCount++;
exception = null;
long oldTime = 0;
try {
// Defines a context for every operation to track them in the logs easily.
if (namesystem != null) {
NDC.push("NN (" + namesystem.getNamenodeId() + ") " + opType.name());
} else {
NDC.push(opType.name());
}
setUp();
txStartTime = System.currentTimeMillis();
oldTime = 0;
EntityManager.begin();
log.debug("tx started");
oldTime = System.currentTimeMillis();
if (rowLevelLock) {
acquireLock();
log.debug("all locks acquired in " + (System.currentTimeMillis() - oldTime) + " msec");
oldTime = System.currentTimeMillis();
EntityManager.preventStorageCall();
}
log.debug("starting in memory processing");
Object obj = performTask();
log.debug("in memory processig finished in " + (System.currentTimeMillis() - oldTime) + " msec");
oldTime = System.currentTimeMillis();
return obj;
} catch (TransactionContextException ex) {
log.error("Could not perfortm task", ex);
rollback = true;
retry = false;
} catch (PersistanceException ex) {
log.error("Tx FAILED. total tx time "+
(System.currentTimeMillis() - txStartTime)+
" msec. Retry("+
retry+") TotalRetryCount("+
RETRY_COUNT+") RemainingRetries("+
(RETRY_COUNT-tryCount)+")", ex);
rollback = true;
retry = true;
} catch (IOException ex) {
exception = ex;
} finally {
try {
if (!rollback) {
EntityManager.commit();
log.debug("tx committed. commit took " + (System.currentTimeMillis() - oldTime) + " msec");
log.debug("Total time for tx is " + (System.currentTimeMillis() - txStartTime) + " msec");
}
} catch (StorageException ex) {
log.error("Could not commit transaction", ex);
rollback = true;
retry = true;
} finally {
try {
if (rollback) {
try {
EntityManager.rollback();
} catch (StorageException ex) {
log.error("Could not rollback transaction", ex);
}
}
if (tryCount == RETRY_COUNT && exception != null) {
throw exception;
}
} finally {
NDC.pop();
}
}
}
}
} finally {
if (systemLevelLock) {
if (writeLock) {
namesystem.writeUnlock();
}
if (readLock) {
namesystem.readUnlock();
}
}
}
return null;
}
public abstract void acquireLock() throws PersistanceException, IOException;
@Override
public TransactionalRequestHandler setParams(Object... params) {
this.params = params;
return this;
}
public void setUp() throws PersistanceException, IOException
{
// Do nothing.
// This can be overriden.
}
}
|
package com.google.sheet.reader.service;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import com.google.api.services.sheets.v4.Sheets.Spreadsheets;
import com.google.api.services.sheets.v4.model.Sheet;
import com.google.api.services.sheets.v4.model.Spreadsheet;
import com.google.api.services.sheets.v4.model.ValueRange;
import com.google.sheet.reader.model.SheetData;
import com.google.sheet.reader.model.SheetMetaData;
@Component
public class GoogleSheetReader {
@Autowired
Spreadsheets googleSheetConfiguration;
public SheetMetaData getMetaData(String sheetid) throws IOException {
Spreadsheet sp = googleSheetConfiguration.get(sheetid).execute();
List<Sheet> sheets = sp.getSheets();
SheetMetaData metaData = new SheetMetaData();
metaData.setSheetID(sheetid);
for(Sheet s: sheets) {
metaData.getSheetNames().add(s.getProperties().getTitle());
}
return metaData;
}
public SheetData getdata(String sheetid, String sheetname) throws IOException {
ValueRange values = googleSheetConfiguration.values().get(sheetid, sheetname).execute();
SheetData data = new SheetData();
List<String> headers = new ArrayList<String>();
for(int j = 0;j<values.getValues().get(0).size();j++) {
headers.add(String.valueOf(values.getValues().get(0).get(j)));
}
data.getHeader().addAll(headers);
for(int i = 1;i<values.getValues().size();i++) {
List<String> row = new ArrayList<String>();
for(int j = 0;j<values.getValues().get(i).size();j++) {
row.add(String.valueOf(values.getValues().get(i).get(j)));
}
data.getRows().add(row);
}
return data;
}
}
|
package fourinline;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.logging.Logger;
public class Sender1 extends Thread
{
byte[] sendData;
DatagramPacket sendPacket;
InetAddress IPAddress;
String command;
int port;
String message;
public Sender1(String s,String message, int portNumber) throws SocketException, UnknownHostException
{
this.port = portNumber;
sendData = new byte[1024];
this.command = s;
this.message=message;
IPAddress = InetAddress.getByName("127.0.0.1");
}
@Override
public void run()
{
while (true)
{
try
{
DatagramSocket socket = new DatagramSocket();
sendData = message.getBytes();
sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
System.out.println("Sent!");
System.out.println("---------------------");
socket.send(sendPacket);
socket.close();
Thread.currentThread().stop();
} catch (IOException ex)
{
Logger.getLogger(ex.getMessage());
}
}
}
} |
/*
* Amy Denham
* CS161-01 Fall 2012
* Project 3
*
*/
import java.awt.*;
import javax.swing.*;
/**
* Face class which draws all the graphics on the clock
*/
public class Face extends JPanel{
final int C_X=400; //center of circle x location
final int C_Y=300; //center of circle y location
final int radius = 200; //radius of circle
private int second=0;
private int minute=0;
private int hour=0;
/**
* Constructor class, starts clock off at 12:00
*/
Face(){
setSecond(0);
setMinute(0);
setHour(12,0);
}
/**
* paint method that draws the face and hands using variables
* determined by setSecond, setMinute, and setHour methods
*/
public void paint(Graphics g) {
super.paint(g);
drawFace(g);
drawSecondHand(second,g);
drawMinuteHand(minute,g);
drawHourHand(hour,g);
}
/**
* set Second hand based on value passed, converting to correct degree
* @param s
*/
public void setSecond(int s){
//second hand = number of seconds times 6 degrees minus 90 degrees
second=s*6-90;
}
/**
* Set Minute hand based on value passed, converting to correct degree
* @param m
*/
public void setMinute(int m){
//minute hand = number of minutes times 6 degrees minus 90 degrees
minute=m*6-90;
}
/**
* Set hour hand based on value passed, converting to correct degree
* @param h
*/
public void setHour(int h, int i){
//hour hand = number of hours times 30 degrees - 90 degrees plus interim passed by variable
//interim is a multiple of six degrees, depending on what minute in the hour the clock starts
hour=(h*30) - 90 + i;
}
/**
* Draw face of clock including outer circle, inner filled circles, tick markets, numbers
* @param g
*/
private void drawFace(Graphics g){
//draw outer circle
g.setColor(Color.black);
drawCircle(C_X,C_Y,radius,g);
//draw larger inner filled oval 1 pixel smaller than outer
g.setColor(Color.orange);
drawFilledCircle(C_X,C_Y,radius-1,g);
//draw smaller inner filled oval 20 pixels smaller than outer
g.setColor(Color.yellow);
drawFilledCircle(C_X,C_Y,radius-20,g);
//draw tick marks
drawTickMarks(g);
//draw numbers
drawNumbers(g);
}
/**
* Method to plot x axis at perimeter of circle
* @param degrees
* @param radius - to determine distance based on center coordinates
* @return
*/
private int plotX(int degrees, int radius){
double radians = 0;
int O_X = 0;
//calculate radians
radians = degrees * Math.PI / 180;
//calculate x using cosine function
O_X = C_X + (int)(radius * Math.cos(radians));
return O_X;
}
/**
* Method to plot y axis at perimeter of circle
* @param degrees
* @param radius - to determine distance based on center coordinates
* @return
*/
private int plotY(int degrees, int radius){
double radians = 0;
int O_Y = 0;
//calculate radians
radians = degrees * Math.PI / 180;
//calculate y using sin function
O_Y = C_Y + (int)(radius * Math.sin(radians));
return O_Y;
}
/**
* Method to draw numbers along the perimeter of the clock face
* @param radius
* @param x center of circle x coordinate
* @param y center of circle y coordinate
* @param g Graphics variable
*/
private void drawNumbers(Graphics g){
int degrees=0; //degree location ofnumber
int L_X=0; //x location of number
int L_Y=0; //y location of number
//set font
Font f = new Font("Dialog", Font.BOLD , 20);
g.setFont(f);
//add number labels to clock
for(int k = 1; k<=12;k++){
//get degrees
degrees = 30*(k-3);
//get x and y plots
//perimeter location, plus/minus half the size of the font for centering
L_X = plotX(degrees, this.radius+50)-10;
L_Y = plotY(degrees, this.radius+50)+10;
//draw number
g.drawString(String.valueOf(k),L_X,L_Y);
}
}
/**
* Method to draw tick marks along the perimeter of the clock face
* @param radius
* @param x center of circle x coordinate
* @param y center of circle y coordinate
* @param g Graphics variable
*/
private void drawTickMarks(Graphics g){
int P_X=0; //x on the perimeter
int P_Y=0; //y on the perimeter
int O_X=0; //outer x of tick mark
int O_Y=0; //outer y of tick mark
//set color of tick marks
g.setColor(Color.black);
//draw short tick marks every six degrees
for(int d=0;d<360;d+=6){
//get x,y on perimeter
O_X=plotX(d,radius);
O_Y=plotY(d,radius);
//get x,y 10 pixels past perimeter
P_X=plotX(d,radius+10);
P_Y=plotY(d,radius+10);
//draw tick marks
g.drawLine(O_X,O_Y,P_X,P_Y);
}
//draw long tick marks every 30 degrees
for(int d=0;d<360;d+=30){
//get x,y on perimeter
O_X=plotX(d,radius);
O_Y=plotY(d,radius);
//get x,y 10 pixels past perimeter
P_X=plotX(d,radius+20);
P_Y=plotY(d,radius+20);
//draw tick marks
g.drawLine(O_X,O_Y,P_X,P_Y);
}
}
/**
* Method to draw a second hand
* @param degrees, to determine second placement
* @param g Graphics variable
*/
private void drawSecondHand(int degrees, Graphics g){
int P_X=0; //x on the perimeter
int P_Y=0; //y on the perimeter
//set color of hand
g.setColor(Color.red);
//get x,y locations on perimeter
P_X=plotX(degrees,radius-5);
P_Y=plotY(degrees,radius-5);
//draw line
g.drawLine(C_X, C_Y, P_X, P_Y);
}
/**
* Method to draw a minute hand
* @param degrees, to determine minute placement
* @param g Graphics variable
*/
private void drawMinuteHand(int degrees, Graphics g){
int P_X=0; //x on the perimeter
int P_Y=0; //y on the perimeter
//set color of hand
g.setColor(Color.blue);
//get x,y locations on perimeter
P_X=plotX(degrees,radius-20);
P_Y=plotY(degrees,radius-20);
//draw line
g.drawLine(C_X, C_Y, P_X, P_Y);
}
/**
* Method to draw an hour hand
* @param degrees, to determine hour placement
* @param g Graphics variable
*/
private void drawHourHand(int degrees, Graphics g){
int P_X=0; //x on the perimeter
int P_Y=0; //y on the perimeter
//set color of hand
g.setColor(Color.blue);
//get x,y locations on perimeter
P_X=plotX(degrees,radius-40);
P_Y=plotY(degrees,radius-40);
//draw three lines next to each other to make it stand out
g.drawLine(C_X, C_Y, P_X, P_Y);
g.drawLine(C_X+1, C_Y-1, P_X+1, P_Y-1);
g.drawLine(C_X+2, C_Y-2, P_X+2, P_Y-2);
}
/**
* Method to draw the outline of a circle
* @param x center of circle x coordinate
* @param y center of circle y coordinate
* @param radius
* @param g
*/
private void drawCircle(int x, int y, int radius, Graphics g){
g.drawOval(x - radius, y - radius, radius*2, radius*2);
}
/**
* Method to draw a filled circle
* @param x center of circle x coordinate
* @param y center of circle y coordinate
* @param radius
* @param g
*/
private void drawFilledCircle(int x, int y, int radius, Graphics g){
g.fillOval(x - radius, y - radius, radius*2, radius*2);
}
}
|
package com.myneu.project.pojo;
import java.util.ArrayList;
import java.util.Collection;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="OrderTemp")
public class OrderTemp {
@Id
@GeneratedValue
@Column(name = "Id", unique = true, nullable =false)
private int Id;
@OneToMany
@JoinTable(joinColumns=@JoinColumn(name="OrderId"), inverseJoinColumns=@JoinColumn(name="productId"))
private Collection<FinalProductsOrder> product = new ArrayList<FinalProductsOrder>();
@Column(name="OrderId")
private int OrderId;
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public Collection<FinalProductsOrder> getProduct() {
return product;
}
public void setProduct(Collection<FinalProductsOrder> product) {
this.product = product;
}
public int getOrderId() {
return OrderId;
}
public void setOrderId(int orderId) {
OrderId = orderId;
}
} |
package edu.uiowa.icts.criterion;
import org.hibernate.Criteria;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.criterion.CriteriaQuery;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.MatchMode;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.TypedValue;
/**
* @author rrlorent
* @date March 20, 2014
*/
public class DateLike implements Criterion {
private static final long serialVersionUID = -6772056160232172164L;
private final String SQL_SERVER = "org.hibernate.dialect.SQLServerDialect";
private final String POSTGRES = "org.hibernate.dialect.PostgreSQLDialect";
// private final String HSQL = "org.hibernate.dialect.HSQLDialect";
// private final String MYSQL = "org.hibernate.dialect.MySQL5Dialect";
private String propertyName;
private String value;
private Dialect dialect;
public DateLike( String propertyName, String value, Dialect dialect ) {
super();
this.propertyName = propertyName;
this.value = value;
this.dialect = dialect;
}
/**
* (non-Javadoc)
* @see org.hibernate.criterion.Criterion#toSqlString(org.hibernate.Criteria, org.hibernate.criterion.CriteriaQuery)
*/
@Override
public String toSqlString( Criteria criteria, CriteriaQuery criteriaQuery ) throws HibernateException {
String[] columns = criteriaQuery.getColumnsUsingProjection( criteria, propertyName );
if ( columns.length != 1 ) {
throw new HibernateException( "like may only be used with single-column properties" );
}
if ( SQL_SERVER.equalsIgnoreCase( dialect.toString() ) ) {
return " cast( convert( varchar( 10 ), " + columns[0] + ", 101 ) as varchar( 10 ) ) like lower( ? ) ";
} else if ( POSTGRES.equalsIgnoreCase( dialect.toString() ) ) {
return " cast( " + columns[0] + " as varchar ) like lower( ? ) ";
} else {
throw new HibernateException( "dialect not supported [" + dialect.toString() + "}" );
}
}
/**
* (non-Javadoc)
* @see org.hibernate.criterion.Criterion#getTypedValues(org.hibernate.Criteria, org.hibernate.criterion.CriteriaQuery)
*/
@Override
public TypedValue[] getTypedValues( Criteria criteria, CriteriaQuery criteriaQuery ) throws HibernateException {
return new TypedValue[] { new TypedValue( new org.hibernate.type.StringType(), MatchMode.START.toMatchString( value.toLowerCase() ), EntityMode.POJO ) };
}
} |
package com.imooc.o2o;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/**
* @author: LieutenantChen
* @create: 2018-09-13 14:46
**/
@RestController
public class HelloSpringBoot {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String hello() {
return "Hello SpringBoot";
}
}
|
/*
* 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 EvaluacionDesempeñoSupervisores;
import BD.BD;
import Clases.EvaluacionSupervisores.BDEvaluacionSupervisores;
import Clases.EvaluacionSupervisores.ClassEvaluacionSupervisores;
import static Formuarios.Inicio.Pane1;
import java.awt.Dimension;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
/**
*
* @author jluis
*/
public class TiposEvaluacionSupervisores extends javax.swing.JInternalFrame {
int id_listaempleados;
int id_evaluacion;
int estado1;
int estado2;
int estado3;
int estado4;
int estado5;
int estado6;
int estado7;
int estado8;
int face;
int no_evaluacion;
String FechaProxima;
ImageIcon iconobtn = new ImageIcon("1481834876_tick_16.png");
/**
* Creates new form TiposEvaluacion
*/
public TiposEvaluacionSupervisores(int id) {
this.id_evaluacion = id;
initComponents();
buscar();
validarrealizadas();
actualizarEstado();
}
private void actualizarEstado() {
if (estado1 == 1 && estado2 == 1 && estado3 == 1 && estado4 == 1 &&
estado5 == 1 && estado6 == 1 && estado7 == 1 && estado8 == 1)
{
try {
/*
int meses = 4;
String FechaS = FECHA.getText();
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yy");
Date fecha = sdf.parse(FechaS);
Calendar calendar = Calendar.getInstance();
calendar.setTime(fecha);
calendar.add(Calendar.MONTH, meses);
FechaProxima = (sdf.format(calendar.getTime()));
*/
int meses = 4;
Date date = fechaF.getDate();
SimpleDateFormat sdf = new SimpleDateFormat("d/MM/yyyy");
String fecha = sdf.format(date);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MONTH, meses);
FechaProxima = (sdf.format(calendar.getTime()));
Connection con = BD.getConnection();
Statement stmt = con.createStatement();
Statement st = con.createStatement();
ResultSet rs = stmt.executeQuery("update BEVALUACION_DESEMPENO set estado = 2 where id_evaluacion ="+id_evaluacion);
ResultSet r = st.executeQuery("update BEVALUACION_DESEMPENO set estado = 1,fecha = '"+FechaProxima+"' where estado = 0 and id_listaempleados ="+id_listaempleados+" and face = "+(face+1)+" and evaluacion =" + no_evaluacion);
rs.close();
r.close();
stmt.close();
st.close();
con.close();
} catch (SQLException error) {
System.out.print(" ERROR QUE OBTIENE EL ULTIMO ID DE INGRESO " + error );
}
}
//System.out.println("1 = "+FechaProxima+ "2 = "+id_listaempleados+" 3 = "+no_evaluacion+" FACE ="+(face+1));
}
private void buscar() {
try {
ClassEvaluacionSupervisores p = BDEvaluacionSupervisores.buscarEmpleadoIDEvaluacionSuper(id_evaluacion);
CODIGO.setText(String.valueOf(p.getCodigo()));
NOMBRE.setText(p.getNombres()); // + ' ' + p.getApellidos());
PUESTO.setText(p.getPuesto());
DEPTO.setText(p.getDepto());
SimpleDateFormat sdf = new SimpleDateFormat("MMMMM-dd-yyyy");
Date datenaci = sdf.parse(p.getFechaS());
fechaF.setDate(datenaci);
//FECHA.setText(p.getFechaS());
FACE.setText(p.getFaceS());
face = p.getFace();
no_evaluacion = p.getNoEvaluacion();
id_evaluacion = p.getId_evaluacion();
id_listaempleados = p.getId_listaempleados();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "ERROR AL OBTENER EL EMPLEADO A EDITAR " + e);
}
}
private void validarrealizadas() {
try {
Connection con = BD.getConnection();
Statement stmt1 = con.createStatement();
ResultSet rs1 = stmt1.executeQuery("select COALESCE(sum(estado),0) as estado from APLANIFICACION where id_evaluacion = " + id_evaluacion);
rs1.next();
int c1 = rs1.getInt("estado");
if (c1 == 1) {
planificacion.setIcon(iconobtn);
estado1 = 1;
}
Statement stmt2 = con.createStatement();
ResultSet rs2 = stmt2.executeQuery("select COALESCE(sum(estado),0) as estado from borientacion where id_evaluacion = " + id_evaluacion);
rs2.next();
int c2 = rs2.getInt("estado");
if (c2 == 1) {
OrientaResultados.setIcon(iconobtn);
estado2 = 1;
}
Statement stmt3 = con.createStatement();
ResultSet rs3 = stmt3.executeQuery("select COALESCE(sum(estado),0) as estado from CRESOLUCION_CONFLICTOS where id_evaluacion = " + id_evaluacion);
rs3.next();
int c3 = rs3.getInt("estado");
if (c3 == 1) {
ResolucionConflictos.setIcon(iconobtn);
estado3 = 1;
}
Statement stmt4 = con.createStatement();
ResultSet rs4 = stmt4.executeQuery("select COALESCE(sum(estado),0) as estado from DTRABAJO_EQUIPO where id_evaluacion = " + id_evaluacion);
rs4.next();
int c4 = rs4.getInt("estado");
if (c4 == 1) {
TrabajoEquipo.setIcon(iconobtn);
estado4 = 1;
}
Statement stmt5 = con.createStatement();
ResultSet rs5 = stmt5.executeQuery("select COALESCE(sum(estado),0) as estado from EORGANIZACION where id_evaluacion = " + id_evaluacion);
rs5.next();
int c5 = rs5.getInt("estado");
if (c5 == 1) {
Organizacion.setIcon(iconobtn);
estado5 = 1;
}
Statement stmt6 = con.createStatement();
ResultSet rs6 = stmt6.executeQuery("select COALESCE(sum(estado),0) as estado from FLIDERAZGO where id_evaluacion = " + id_evaluacion);
rs6.next();
int c6 = rs6.getInt("estado");
if (c6 == 1) {
Liderazgo.setIcon(iconobtn);
estado6 = 1;
}
Statement stmt7 = con.createStatement();
ResultSet rs7 = stmt7.executeQuery("select COALESCE(sum(estado),0) as estado from gresponsabilidad where id_evaluacion = " + id_evaluacion);
rs7.next();
int c7 = rs7.getInt("estado");
if (c7 == 1) {
Responsabilidad.setIcon(iconobtn);
estado7 = 1;
}
Statement stmt8 = con.createStatement();
ResultSet rs8 = stmt8.executeQuery("select COALESCE(sum(estado),0) as estado from HINICIATIVA where id_evaluacion = " + id_evaluacion);
rs8.next();
int c8 = rs8.getInt("estado");
if (c8 == 1) {
Iniciativa.setIcon(iconobtn);
estado8 = 1;
}
actualizarEstado();
} catch (Exception e) {
System.out.println("ERROR " + e);
}
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
jLabel3 = new javax.swing.JLabel();
jPanel1 = new javax.swing.JPanel();
jPanel3 = new javax.swing.JPanel();
planificacion = new javax.swing.JButton();
Organizacion = new javax.swing.JButton();
Liderazgo = new javax.swing.JButton();
OrientaResultados = new javax.swing.JButton();
ResolucionConflictos = new javax.swing.JButton();
TrabajoEquipo = new javax.swing.JButton();
Iniciativa = new javax.swing.JButton();
Responsabilidad = new javax.swing.JButton();
jPanel2 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
CODIGO = new javax.swing.JTextField();
jLabel2 = new javax.swing.JLabel();
NOMBRE = new javax.swing.JTextField();
jLabel4 = new javax.swing.JLabel();
PUESTO = new javax.swing.JTextField();
jPanel4 = new javax.swing.JPanel();
jLabel6 = new javax.swing.JLabel();
jLabel7 = new javax.swing.JLabel();
FACE = new javax.swing.JTextField();
jLabel5 = new javax.swing.JLabel();
DEPTO = new javax.swing.JTextField();
fechaF = new com.toedter.calendar.JDateChooser();
jButton1 = new javax.swing.JButton();
jLabel3.setText("jLabel3");
setClosable(true);
setTitle("EVALUACION DE DESEMPEÑO SUPERVISORES");
addInternalFrameListener(new javax.swing.event.InternalFrameListener() {
public void internalFrameActivated(javax.swing.event.InternalFrameEvent evt) {
}
public void internalFrameClosed(javax.swing.event.InternalFrameEvent evt) {
formInternalFrameClosed(evt);
}
public void internalFrameClosing(javax.swing.event.InternalFrameEvent evt) {
formInternalFrameClosing(evt);
}
public void internalFrameDeactivated(javax.swing.event.InternalFrameEvent evt) {
}
public void internalFrameDeiconified(javax.swing.event.InternalFrameEvent evt) {
}
public void internalFrameIconified(javax.swing.event.InternalFrameEvent evt) {
}
public void internalFrameOpened(javax.swing.event.InternalFrameEvent evt) {
}
});
jPanel1.setBackground(new java.awt.Color(153, 204, 255));
jPanel3.setBackground(new java.awt.Color(204, 204, 255));
planificacion.setText("1. Planificacion");
planificacion.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
planificacionActionPerformed(evt);
}
});
Organizacion.setText("5. Organización");
Organizacion.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
OrganizacionActionPerformed(evt);
}
});
Liderazgo.setText("6. Liderazgo");
Liderazgo.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
LiderazgoActionPerformed(evt);
}
});
OrientaResultados.setText("2. Orientacion a Resultados");
OrientaResultados.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
OrientaResultadosActionPerformed(evt);
}
});
ResolucionConflictos.setText("3. Resolucion de Conflictos");
ResolucionConflictos.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
ResolucionConflictosActionPerformed(evt);
}
});
TrabajoEquipo.setText("4. Trabajo en Equipo");
TrabajoEquipo.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
TrabajoEquipoActionPerformed(evt);
}
});
Iniciativa.setText("8. Iniciativa");
Iniciativa.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
IniciativaActionPerformed(evt);
}
});
Responsabilidad.setText("7. Responsabilidad");
Responsabilidad.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
ResponsabilidadActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);
jPanel3.setLayout(jPanel3Layout);
jPanel3Layout.setHorizontalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel3Layout.createSequentialGroup()
.addGap(15, 15, 15)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(planificacion, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(OrientaResultados, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)
.addComponent(ResolucionConflictos, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(TrabajoEquipo, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(36, 36, 36)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(Iniciativa, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(Responsabilidad, javax.swing.GroupLayout.DEFAULT_SIZE, 163, Short.MAX_VALUE))
.addComponent(Organizacion, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.PREFERRED_SIZE, 163, javax.swing.GroupLayout.PREFERRED_SIZE))
.addComponent(Liderazgo, javax.swing.GroupLayout.PREFERRED_SIZE, 163, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(0, 15, Short.MAX_VALUE))
);
jPanel3Layout.setVerticalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel3Layout.createSequentialGroup()
.addGap(18, 18, 18)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(planificacion)
.addComponent(Organizacion))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(OrientaResultados, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(Liderazgo, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(ResolucionConflictos, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(Responsabilidad, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(TrabajoEquipo)
.addComponent(Iniciativa))
.addContainerGap(14, Short.MAX_VALUE))
);
jLabel1.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel1.setText("CODIGO:");
CODIGO.setEditable(false);
jLabel2.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel2.setText("NOMBRE:");
NOMBRE.setEditable(false);
jLabel4.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel4.setText("PUESTO:");
PUESTO.setEditable(false);
PUESTO.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
PUESTOActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(NOMBRE)
.addComponent(CODIGO)
.addComponent(PUESTO)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel1)
.addComponent(jLabel2)
.addComponent(jLabel4))
.addGap(0, 240, Short.MAX_VALUE)))
.addContainerGap())
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(CODIGO, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(10, 10, 10)
.addComponent(jLabel2)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(NOMBRE, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jLabel4)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(PUESTO, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
jLabel6.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel6.setText("FECHA:");
jLabel7.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel7.setText("FASE:");
FACE.setEditable(false);
jLabel5.setFont(new java.awt.Font("Tahoma", 1, 12)); // NOI18N
jLabel5.setText("DEPARTAMENTO:");
DEPTO.setEditable(false);
DEPTO.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
DEPTOActionPerformed(evt);
}
});
fechaF.setDateFormatString("MMMMM-dd-yyyy");
fechaF.setEnabled(false);
javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4);
jPanel4.setLayout(jPanel4Layout);
jPanel4Layout.setHorizontalGroup(
jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel4Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(FACE)
.addComponent(DEPTO)
.addGroup(jPanel4Layout.createSequentialGroup()
.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel7)
.addComponent(jLabel6)
.addComponent(jLabel5))
.addGap(0, 0, Short.MAX_VALUE))
.addComponent(fechaF, javax.swing.GroupLayout.DEFAULT_SIZE, 293, Short.MAX_VALUE))
.addContainerGap())
);
jPanel4Layout.setVerticalGroup(
jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel4Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel5)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(DEPTO, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(12, 12, 12)
.addComponent(jLabel6)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(fechaF, javax.swing.GroupLayout.PREFERRED_SIZE, 24, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jLabel7)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(FACE, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
jButton1.setText("SALIR");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jPanel4, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(jPanel1Layout.createSequentialGroup()
.addGap(101, 101, 101)
.addComponent(jPanel3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(jPanel1Layout.createSequentialGroup()
.addGap(280, 280, 280)
.addComponent(jButton1)))
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jPanel4, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(18, 18, 18)
.addComponent(jPanel3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jButton1)
.addContainerGap(26, Short.MAX_VALUE))
);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
);
pack();
}// </editor-fold>//GEN-END:initComponents
private void planificacionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_planificacionActionPerformed
if (estado1 == 0){
aEvaluacionPlanificacion ma = new aEvaluacionPlanificacion(id_evaluacion, Integer.parseInt(CODIGO.getText()));
Pane1.add(ma);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = ma.getSize();
ma.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
ma.show();
this.dispose();
}
}//GEN-LAST:event_planificacionActionPerformed
private void OrganizacionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_OrganizacionActionPerformed
System.out.println("estado = "+estado5);
if (estado5 == 0){
eEvaluacionOrganizacion ma = new eEvaluacionOrganizacion(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(ma);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = ma.getSize();
ma.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
ma.show();
this.dispose();
}
}//GEN-LAST:event_OrganizacionActionPerformed
private void LiderazgoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_LiderazgoActionPerformed
if (estado6 == 0){
fEvaluacionLiderazgo ma = new fEvaluacionLiderazgo(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(ma);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = ma.getSize();
ma.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
ma.show();
this.dispose();
}
}//GEN-LAST:event_LiderazgoActionPerformed
private void OrientaResultadosActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_OrientaResultadosActionPerformed
if (estado2 == 0){
bEvaluacionOrientacionAresultados ma = new bEvaluacionOrientacionAresultados(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(ma);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = ma.getSize();
ma.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
ma.show();
this.dispose();
}
}//GEN-LAST:event_OrientaResultadosActionPerformed
private void DEPTOActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_DEPTOActionPerformed
}//GEN-LAST:event_DEPTOActionPerformed
private void PUESTOActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_PUESTOActionPerformed
}//GEN-LAST:event_PUESTOActionPerformed
private void formInternalFrameClosing(javax.swing.event.InternalFrameEvent evt) {//GEN-FIRST:event_formInternalFrameClosing
InicioEvaluacioSupervisores tra = new InicioEvaluacioSupervisores();
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
}//GEN-LAST:event_formInternalFrameClosing
private void ResolucionConflictosActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_ResolucionConflictosActionPerformed
if (estado3 == 0){
cEvaluacionResolucionConflictos tra = new cEvaluacionResolucionConflictos(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
this.dispose();
}
}//GEN-LAST:event_ResolucionConflictosActionPerformed
private void TrabajoEquipoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_TrabajoEquipoActionPerformed
if (estado4 == 0){
dEvaluacionTrabajoEnEquipo tra = new dEvaluacionTrabajoEnEquipo(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
this.dispose();
}
}//GEN-LAST:event_TrabajoEquipoActionPerformed
private void IniciativaActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_IniciativaActionPerformed
if (estado8 == 0){
hEvaluacionIniciativa tra = new hEvaluacionIniciativa(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
this.dispose();
}
}//GEN-LAST:event_IniciativaActionPerformed
private void ResponsabilidadActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_ResponsabilidadActionPerformed
if (estado7 == 0){
gEvaluacionResponsabilidad tra = new gEvaluacionResponsabilidad(id_evaluacion,Integer.parseInt(CODIGO.getText()));
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
this.dispose();
}
}//GEN-LAST:event_ResponsabilidadActionPerformed
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
this.dispose();
InicioEvaluacioSupervisores tra = new InicioEvaluacioSupervisores();
Pane1.add(tra);
Dimension desktopSize = Pane1.getSize();
Dimension FrameSize = tra.getSize();
tra.setLocation((desktopSize.width - FrameSize.width) / 2, (desktopSize.height - FrameSize.height) / 2);
tra.show();
}//GEN-LAST:event_jButton1ActionPerformed
private void formInternalFrameClosed(javax.swing.event.InternalFrameEvent evt) {//GEN-FIRST:event_formInternalFrameClosed
}//GEN-LAST:event_formInternalFrameClosed
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JTextField CODIGO;
private javax.swing.JTextField DEPTO;
private javax.swing.JTextField FACE;
private javax.swing.JButton Iniciativa;
private javax.swing.JButton Liderazgo;
private javax.swing.JTextField NOMBRE;
private javax.swing.JButton Organizacion;
private javax.swing.JButton OrientaResultados;
private javax.swing.JTextField PUESTO;
private javax.swing.JButton ResolucionConflictos;
private javax.swing.JButton Responsabilidad;
private javax.swing.JButton TrabajoEquipo;
private com.toedter.calendar.JDateChooser fechaF;
private javax.swing.JButton jButton1;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel3;
private javax.swing.JPanel jPanel4;
private javax.swing.JButton planificacion;
// End of variables declaration//GEN-END:variables
}
|
package com.distributie.view;
import java.util.ArrayList;
import java.util.HashMap;
import android.app.ActionBar;
import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import butterknife.ButterKnife;
import butterknife.InjectView;
import com.distributie.beans.Borderou;
import com.distributie.beans.Factura;
import com.distributie.enums.EnumOperatiiBorderou;
import com.distributie.enums.TipBorderou;
import com.distributie.listeners.BorderouriDAOListener;
import com.distributie.listeners.CustomSpinnerListener;
import com.distributie.model.BorderouriDAOImpl;
import com.distributie.model.FacturiBorderou;
import com.distributie.model.HandleJSONData;
import com.distributie.model.InfoStrings;
import com.distributie.model.UserInfo;
public final class AfisBorderouri extends Activity implements CustomSpinnerListener, BorderouriDAOListener {
private Dialog dialogSelInterval;
private String intervalAfisare = "0";
private SimpleAdapter adapterBorderouri, adapterEvenimente;
private static ArrayList<HashMap<String, String>> listBorderouri = new ArrayList<HashMap<String, String>>();
private static ArrayList<HashMap<String, String>> listEvenimente = new ArrayList<HashMap<String, String>>();
private static String selectedBorderou = "0";
private TipBorderou selectedTip;
@InjectView(R.id.listEvenimente)
ListView listViewEvenimente;
@InjectView(R.id.textStartBorderou)
TextView textStartBorderou;
@InjectView(R.id.spinnerBorderouri)
Spinner spinnerBorderouri;
private CustomSpinnerClass borderouClass;
private Activity context;
BorderouriDAOImpl borderouri;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setTheme(R.style.LRTheme);
setContentView(R.layout.afiseaza_borderou);
ActionBar actionBar = getActionBar();
actionBar.setTitle("Afisare borderou");
actionBar.setDisplayHomeAsUpEnabled(true);
borderouri = BorderouriDAOImpl.getInstance(this);
borderouri.setBorderouEventListener(this);
ButterKnife.inject(this);
InitialUISetup();
context = this;
}
private void InitialUISetup() {
try {
textStartBorderou.setVisibility(View.GONE);
borderouClass = new CustomSpinnerClass();
listBorderouri.clear();
adapterBorderouri = new SimpleAdapter(this, listBorderouri, R.layout.custom_row_list_borderouri,
new String[] { "nrCrt", "codBorderou", "dataBorderou", "tipBorderou", "eveniment" }, new int[] {
R.id.textNrCrt, R.id.textCodBorderou, R.id.textDataBorderou, R.id.textTipBorderou,
R.id.textEvenimentBorderou });
spinnerBorderouri.setAdapter(adapterBorderouri);
spinnerBorderouri.setVisibility(View.INVISIBLE);
spinnerBorderouri.setOnItemSelectedListener(borderouClass);
borderouClass.setListener(this);
listEvenimente.clear();
adapterEvenimente = new SimpleAdapter(this, listEvenimente, R.layout.custom_row_list_evenimente,
new String[] { "nrCrt", "numeClient", "ev1", "timpEv1", "ev2", "timpEv2", "adresaClient" },
new int[] { R.id.textNrCrt, R.id.textNumeClient, R.id.textEv1, R.id.textTimpEv1, R.id.textEv2,
R.id.textTimpEv2, R.id.textAdresaClient });
listViewEvenimente.setAdapter(adapterEvenimente);
performIncarcaBorderouri("0");
} catch (Exception ex) {
Toast.makeText(context, ex.toString(), Toast.LENGTH_SHORT).show();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
createMenu(menu);
return true;
}
private void createMenu(Menu menu) {
MenuItem mnu1 = menu.add(0, 0, 0, "Interval");
mnu1.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM | MenuItem.SHOW_AS_ACTION_WITH_TEXT);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case 0:
String[] options = { "Astazi", "In ultimele 7 zile", "In ultimele 30 de zile" };
dialogSelInterval = new Dialog(this);
dialogSelInterval.setContentView(R.layout.selintervaldialogafiscmd);
dialogSelInterval.setTitle("Afiseaza borderourile livrate ");
Spinner spinnerSelInterval = (Spinner) dialogSelInterval.findViewById(R.id.spinnerSelInterval);
ArrayList<HashMap<String, String>> listOptInterval = new ArrayList<HashMap<String, String>>();
SimpleAdapter adapterOptions = new SimpleAdapter(this, listOptInterval, R.layout.customrowselinterval,
new String[] { "optInterval" }, new int[] { R.id.textTipInterval });
HashMap<String, String> temp;
for (int ii = 0; ii < options.length; ii++) {
temp = new HashMap<String, String>();
temp.put("optInterval", options[ii]);
listOptInterval.add(temp);
}
spinnerSelInterval.setAdapter(adapterOptions);
spinnerSelInterval.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
intervalAfisare = String.valueOf(pos);
}
public void onNothingSelected(AdapterView<?> parent) {
}
});
Button btnOkInterval = (Button) dialogSelInterval.findViewById(R.id.btnOkInterval);
btnOkInterval.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
performIncarcaBorderouri(intervalAfisare);
dialogSelInterval.dismiss();
}
});
dialogSelInterval.show();
return true;
case android.R.id.home:
Intent nextScreen = new Intent(this, MainMenu.class);
startActivity(nextScreen);
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
@Override
public void onBackPressed() {
Intent nextScreen = new Intent(getApplicationContext(), MainMenu.class);
startActivity(nextScreen);
finish();
return;
}
public void performIncarcaBorderouri(String intervalAfisare) {
try {
selectedBorderou = "0";
listEvenimente.clear();
listViewEvenimente.setAdapter(adapterEvenimente);
listEvenimente.clear();
listViewEvenimente.setAdapter(adapterEvenimente);
listViewEvenimente.setVisibility(View.INVISIBLE);
borderouri.getBorderouri(UserInfo.getInstance().getId(), "t", intervalAfisare);
} catch (Exception e) {
Toast.makeText(context, e.toString(), Toast.LENGTH_SHORT).show();
}
}
private void populateListBorderouri(String borderouri) {
HandleJSONData objListBorderouri = new HandleJSONData(context, borderouri);
ArrayList<Borderou> borderouriArray = objListBorderouri.decodeJSONBorderouri();
listBorderouri.clear();
if (borderouriArray.size() > 0) {
spinnerBorderouri.setVisibility(View.VISIBLE);
spinnerBorderouri.setEnabled(true);
HashMap<String, String> temp;
for (int i = 0; i < borderouriArray.size(); i++) {
temp = new HashMap<String, String>();
temp.put("nrCrt", String.valueOf(i + 1) + ".");
temp.put("codBorderou", borderouriArray.get(i).getNumarBorderou());
temp.put("dataBorderou", borderouriArray.get(i).getDataEmiterii());
temp.put("tipBorderou", InfoStrings.getStringTipBorderou(borderouriArray.get(i).getTipBorderou())
.toString());
temp.put("eveniment", borderouriArray.get(i).getEvenimentBorderou());
listBorderouri.add(temp);
}
} else {
textStartBorderou.setText("");
Toast.makeText(context, "Nu exista borderouri!", Toast.LENGTH_SHORT).show();
}
spinnerBorderouri.setAdapter(adapterBorderouri);
}
public void performGetBorderouEvents() {
try {
borderouri.getFacturiBorderou(selectedBorderou, selectedTip);
} catch (Exception ex) {
Toast.makeText(context, ex.toString(), Toast.LENGTH_LONG).show();
}
}
private void populateEventsList(String eventsData) {
try {
HandleJSONData objListFacturi = new HandleJSONData(context, eventsData);
ArrayList<Factura> facturiArray = objListFacturi.decodeJSONFacturiBorderou();
textStartBorderou.setVisibility(View.GONE);
if (facturiArray.size() > 0) {
listEvenimente.clear();
listViewEvenimente.setVisibility(View.VISIBLE);
String tempDataStartCursa = facturiArray.get(0).getDataStartCursa();
FacturiBorderou facturi = new FacturiBorderou(context);
listViewEvenimente.setAdapter(facturi.getFacturiBorderouAdapter(facturiArray, selectedTip, false));
if (tempDataStartCursa.length() > 0) {
String[] varTokStartBord = tempDataStartCursa.split(":");
String strStartBorderou = varTokStartBord[0].substring(6, 8) + "-"
+ varTokStartBord[0].substring(4, 6) + "-" + varTokStartBord[0].substring(0, 4) + " "
+ varTokStartBord[1].substring(0, 2) + ":" + varTokStartBord[1].substring(2, 4);
textStartBorderou.setText("Start borderou " + strStartBorderou);
textStartBorderou.setVisibility(View.VISIBLE);
}
}
} catch (Exception ex) {
Toast.makeText(context, "eroare " + ex.toString(), Toast.LENGTH_LONG).show();
}
}
@Override
public void onSelectedSpinnerItem(int spinnerId, HashMap<String, String> map) {
if (spinnerId == R.id.spinnerBorderouri) {
selectedBorderou = map.get("codBorderou");
selectedTip = TipBorderou.valueOf(map.get("tipBorderou"));
performGetBorderouEvents();
}
}
@Override
public void loadComplete(String result, EnumOperatiiBorderou methodName) {
switch (methodName) {
case GET_BORDEROURI:
populateListBorderouri(result);
break;
case GET_FACTURI_BORDEROU:
populateEventsList(result);
break;
default:
break;
}
}
} |
package com.soft1841.book.controller;
import com.soft1841.book.entity.Admin;
import com.soft1841.book.service.AdminService;
import com.soft1841.book.utils.ServiceFactory;
import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Alert;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import java.net.URL;
import java.util.ResourceBundle;
public class PersonalController implements Initializable {
@FXML
private Label adminName;
@FXML
private TextField adminPassword;
@FXML
private ImageView adminImg;
private AdminService adminService = ServiceFactory.getAdminServiceInstance();
private Admin admin;
public void setAdmin(Admin admin) {
this.admin = admin;
}
@Override
public void initialize(URL location, ResourceBundle resources) {
Platform.runLater(new Runnable() {
@Override
public void run() {
adminImg.setImage(new Image(admin.getAvatar()));
adminName.setText(admin.getName());
adminPassword.setText(admin.getPassword());
}
});
}
public void edit() {
//激活密码框为可编辑状态，同时改变样式
adminPassword.setEditable(true);
adminPassword.getStyleClass().add("input-group");
adminPassword.setOnMouseClicked(event -> {
adminPassword.setText("");
});
}
public void save() {
//获取密码框的值
String passString = adminPassword.getText().trim();
//更新管理员密码
admin.setPassword(passString);
adminService.updateAdmin(admin);
Alert alert = new Alert(Alert.AlertType.INFORMATION);
alert.setTitle("提示");
alert.setContentText("密码修改成功");
alert.showAndWait();
}
}
|
package org.ohdsi.webapi.service.dto;
import org.ohdsi.circe.check.Warning;
import java.util.List;
public class CheckResultDTO {
private Integer cohortDefinitionId;
private List<Warning> warnings;
public CheckResultDTO(Integer cohortDefinitionId, List<Warning> warnings) {
this.cohortDefinitionId = cohortDefinitionId;
this.warnings = warnings;
}
public Integer getCohortDefinitionId() {
return cohortDefinitionId;
}
public void setCohortDefinitionId(Integer cohortDefinitionId) {
this.cohortDefinitionId = cohortDefinitionId;
}
public List<Warning> getWarnings() {
return warnings;
}
public void setWarnings(List<Warning> warnings) {
this.warnings = warnings;
}
}
|
package dev.liambloom.softwareEngineering.chapter12;
import java.util.function.Function;
import java.util.function.BiFunction;
import java.util.HashMap;
import java.util.Set;
import java.util.Arrays;
// At some point I would like to add support for some form of ArrayMap, to allow exercise20 to use this
public class MemorizingRecursive<K, V> implements Function<K, V> {
private final HashMap<K, V> memory;
private final BiFunction<MemorizingRecursive<K, V>, K, V> f;
public MemorizingRecursive(BiFunction<MemorizingRecursive<K, V>, K, V> f) {
this.f = f;
this.memory = new HashMap<>();
}
public MemorizingRecursive(BiFunction<MemorizingRecursive<K, V>, K, V> f, HashMap<K, V> initial) {
this.f = f;
this.memory = initial;
}
public V apply(K i) {
if (!i.getClass().isPrimitive()) {
final Set<K> keys = memory.keySet();
for (K e : keys) {
if (i.getClass().isArray() ? Arrays.equals((Object[]) i, (Object[]) e) : i.equals(e)) {
return memory.get(e);
}
}
}
else if (memory.containsKey(i)) return memory.get(i);
final V r = f.apply(this, i);
memory.put(i, r);
return r;
}
} |
/*
* 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 BDQueryEmpleados;
import BD.BD;
import Clases.empleados.ListaMaestro;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
*
* @author jluis
*/
public class IngresoEmpleado {
public static void insertarEmpleado(ListaMaestro c) throws SQLException {
Connection cnn = BD.getConnection();
PreparedStatement p = null;
p = cnn.prepareStatement("insert into ALISTAEMPLEADOS"
+ "(ID_LISTAEMPLEADOS,CODIGO,NOMBRES,APELLIDOS,F_NACIMIENTO,DPI,DPIEXTENDIDO,DIRECCION,NIT,TELEFONO,T_SANGRE,"
+ " CORREO_ELECTRO,ESTUDIOS_ULTIMOS,IGSS,IRTRA,ESTADO_CIVIL,SEXO,CUENTA_BANCO,DEPARTAMENTO,PUESTO,"
+ " FECHA_INGRESO,ORDINARIO,BONIFICACION,FOTOGRAFIA,DISCAPACIDAD,TIPODISCA,NIVELACADEMICO,ESTADO,EVALUADOPOR,MARCAJE) "
+ "values (IDEMPLEADO.nextval,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?)");
p.setInt(1, c.getCODIGO());
p.setString(2, c.getNOMBRES());
p.setString(3, c.getAPELLIDOS());
p.setDate(4, new java.sql.Date(c.getF_NACIMIENTO().getTime()));
p.setString(5, c.getDPI());
p.setString(6, c.getDPIEXTENDIDO());
p.setString(7, c.getDIRECCION());
p.setString(8, c.getNIT());
p.setString(9, c.getTELEFONO());
p.setString(10, c.getT_SANGRE());
p.setString(11, c.getCORREO_ELECTRO());
p.setString(12, c.getESTUDIOS_ULTIMOS());
p.setString(13, c.getIGSS());
p.setString(14, c.getIRTRA());
p.setString(15, c.getESTADO_CIVIL());
p.setString(16, c.getSEXO());
p.setString(17, c.getCUENTA_BANCO());
p.setInt(18, c.getDEPARTAMENTO());
p.setString(19, c.getPUESTO());
p.setDate(20, new java.sql.Date(c.getFECHA_INGRESO().getTime()));
p.setDouble(21, c.getORDINARIO());
p.setDouble(22, c.getBONIFICACION());
p.setBinaryStream(23, c.getFOTOGRAFIA(),c.getLongitudBytes());
p.setInt(24, c.getDiscapacidad());
p.setString(25, c.getTipoDiscapa());
p.setString(26, c.getNivelAcademico());
p.setInt(27, c.getEvaluadopor());
p.setInt(28, c.getMarcaje());
p.executeUpdate();
cnn.close();
p.close();
}
public static void ActualizarEmpleado(ListaMaestro c) throws SQLException {
Connection cnn = BD.getConnection();
PreparedStatement p = null;
p = cnn.prepareStatement("update ALISTAEMPLEADOS set CODIGO =?, NOMBRES = ?,APELLIDOS = ?,F_NACIMIENTO = ?,DPI = ?,DPIEXTENDIDO = ?,DIRECCION = ?,NIT = ?,TELEFONO = ?,T_SANGRE = ?,"
+ " CORREO_ELECTRO = ?,ESTUDIOS_ULTIMOS = ?,IGSS = ?,IRTRA = ?,ESTADO_CIVIL = ?,SEXO = ?,CUENTA_BANCO = ?,DEPARTAMENTO = ?,PUESTO = ?,"
+ " FECHA_INGRESO = ?,ORDINARIO = ?,BONIFICACION = ?,FOTOGRAFIA = ?,DISCAPACIDAD = ?, TIPODISCA = ?, NIVELACADEMICO = ?,EVALUADOPOR = ?, MARCAJE = ? where id_listaempleados="+c.getID_LISTAEMPLEADOS());
p.setInt(1, c.getCODIGO());
p.setString(2, c.getNOMBRES());
p.setString(3, c.getAPELLIDOS());
p.setDate(4, new java.sql.Date(c.getF_NACIMIENTO().getTime()));
p.setString(5, c.getDPI());
p.setString(6, c.getDPIEXTENDIDO());
p.setString(7, c.getDIRECCION());
p.setString(8, c.getNIT());
p.setString(9, c.getTELEFONO());
p.setString(10, c.getT_SANGRE());
p.setString(11, c.getCORREO_ELECTRO());
p.setString(12, c.getESTUDIOS_ULTIMOS());
p.setString(13, c.getIGSS());
p.setString(14, c.getIRTRA());
p.setString(15, c.getESTADO_CIVIL());
p.setString(16, c.getSEXO());
p.setString(17, c.getCUENTA_BANCO());
p.setInt(18, c.getDEPARTAMENTO());
p.setString(19, c.getPUESTO());
p.setDate(20, new java.sql.Date(c.getFECHA_INGRESO().getTime()));
p.setDouble(21, c.getORDINARIO());
p.setDouble(22, c.getBONIFICACION());
p.setBinaryStream(23, c.getFOTOGRAFIA(),c.getLongitudBytes());
p.setInt(24, c.getDiscapacidad());
p.setString(25, c.getTipoDiscapa());
p.setString(26, c.getNivelAcademico());
p.setInt(27, c.getEvaluadopor());
p.setInt(28, c.getMarcaje());
p.executeUpdate();
cnn.close();
p.close();
}
public static void ActualizarEmpleadoSinfoto(ListaMaestro c) throws SQLException {
Connection cnn = BD.getConnection();
PreparedStatement p = null;
p = cnn.prepareStatement("update ALISTAEMPLEADOS set CODIGO =?, NOMBRES = ?,APELLIDOS = ?,F_NACIMIENTO = ?,DPI = ?,DPIEXTENDIDO = ?,DIRECCION = ?,NIT = ?,TELEFONO = ?,T_SANGRE = ?,"
+ " CORREO_ELECTRO = ?,ESTUDIOS_ULTIMOS = ?,IGSS = ?,IRTRA = ?,ESTADO_CIVIL = ?,SEXO = ?,CUENTA_BANCO = ?,DEPARTAMENTO = ?,PUESTO = ?,"
+ " FECHA_INGRESO = ?,ORDINARIO = ?,BONIFICACION = ? ,DISCAPACIDAD = ?,TIPODISCA = ?, NIVELACADEMICO = ?, EVALUADOPOR = ?, MARCAJE = ? where id_listaempleados="+c.getID_LISTAEMPLEADOS());
p.setInt(1, c.getCODIGO());
p.setString(2, c.getNOMBRES());
p.setString(3, c.getAPELLIDOS());
p.setDate(4, new java.sql.Date(c.getF_NACIMIENTO().getTime()));
p.setString(5, c.getDPI());
p.setString(6, c.getDPIEXTENDIDO());
p.setString(7, c.getDIRECCION());
p.setString(8, c.getNIT());
p.setString(9, c.getTELEFONO());
p.setString(10, c.getT_SANGRE());
p.setString(11, c.getCORREO_ELECTRO());
p.setString(12, c.getESTUDIOS_ULTIMOS());
p.setString(13, c.getIGSS());
p.setString(14, c.getIRTRA());
p.setString(15, c.getESTADO_CIVIL());
p.setString(16, c.getSEXO());
p.setString(17, c.getCUENTA_BANCO());
p.setInt(18, c.getDEPARTAMENTO());
p.setString(19, c.getPUESTO());
p.setDate(20, new java.sql.Date(c.getFECHA_INGRESO().getTime()));
p.setDouble(21, c.getORDINARIO());
p.setDouble(22, c.getBONIFICACION());
p.setInt(23, c.getDiscapacidad());
p.setString(24, c.getTipoDiscapa());
p.setString(25, c.getNivelAcademico());
p.setInt(26, c.getEvaluadopor());
p.setInt(27, c.getMarcaje());
p.executeUpdate();
cnn.close();
p.close();
}
public static ListaMaestro buscarEmpleado(int id) throws SQLException {
return buscarEmple(id, null);
}
public static ListaMaestro buscarEmple(int id, ListaMaestro p) throws SQLException {
Connection cnn = BD.getConnection();
try {
PreparedStatement ps = null;
ps = cnn.prepareStatement("select id_listaempleados,CODIGO,NOMBRES,APELLIDOS,to_char(F_NACIMIENTO,'dd/mm/yyyy') as F_NACIMIENTO,to_char(FECHA_BAJA,'dd/mm/yyyy') as FECHABAJA ,"
+ "MOTIVO_BAJA,DPI,DPIEXTENDIDO,DIRECCION,NIT,TELEFONO,T_SANGRE,CORREO_ELECTRO,ESTUDIOS_ULTIMOS,ESTUDIOS_ACTUALES,IGSS,IRTRA,ESTADO_CIVIL,"
+ "DECODE(SEXO,'F','FEMENINO','M','MASCULINO') AS SEXO,CUENTA_BANCO,"
+ "DECODE(NVL(DEPARTAMENTO,0),0,'SELECCIONAR...',1,'INSPECCION',2,'TESTING',3,'CHIPS',4,'STRIP Y POTTING',5,'TRANSFORMADORES',6,'TALLER',7,'BODEGA',8,'ADMINISTRACION',9,'GERENCIA',10,'TECNOLOGIA DE LA INFORMACION/MATENIMIENTO',11,'MOLDING') AS DEPTO,"
+ "PUESTO,to_char(FECHA_INGRESO,'dd/mm/yy') as FECHA_INGRESO,ORDINARIO,BONIFICACION,DISCAPACIDAD,TIPODISCA,NIVELACADEMICO,EVALUADOPOR,MARCAJE FROM alistaempleados where codigo = ?");
ps.setInt(1, id);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
if (p == null) {
p = new ListaMaestro() {
};
}
p.setID_LISTAEMPLEADOS(rs.getInt("id_listaempleados"));
p.setCODIGO(rs.getInt("CODIGO"));
p.setNOMBRES(rs.getString("NOMBRES"));
p.setAPELLIDOS(rs.getString("APELLIDOS"));
p.setF_nacimiento(rs.getString("F_NACIMIENTO"));
p.setDPI(rs.getString("DPI"));
p.setDPIEXTENDIDO(rs.getString("DPIEXTENDIDO"));
p.setDIRECCION(rs.getString("DIRECCION"));
p.setNIT(rs.getString("NIT"));
p.setTELEFONO(rs.getString("TELEFONO"));
p.setT_SANGRE(rs.getString("T_SANGRE"));
p.setCORREO_ELECTRO(rs.getString("CORREO_ELECTRO"));
p.setESTUDIOS_ULTIMOS(rs.getString("ESTUDIOS_ULTIMOS"));
p.setESTUDIOS_ACTUALES(rs.getString("ESTUDIOS_ACTUALES"));
p.setIGSS(rs.getString("IGSS"));
p.setIRTRA(rs.getString("IRTRA"));
p.setESTADO_CIVIL(rs.getString("ESTADO_CIVIL"));
p.setSEXO(rs.getString("SEXO"));
p.setCUENTA_BANCO(rs.getString("CUENTA_BANCO"));
p.setDepto(rs.getString("DEPTO"));
p.setPUESTO(rs.getString("PUESTO"));
p.setF_ingreso(rs.getString("FECHA_INGRESO"));
p.setORDINARIO(rs.getDouble("ORDINARIO"));
p.setBONIFICACION(rs.getDouble("BONIFICACION"));
p.setDiscapacidad(rs.getInt("DISCAPACIDAD"));
p.setTipoDiscapa(rs.getString("TIPODISCA"));
p.setNivelAcademico(rs.getString("NIVELACADEMICO"));
p.setEvaluadopor(rs.getInt("EVALUADOPOR"));
p.setFechadebaja(rs.getString("FECHABAJA"));
p.setMOTIVO_BAJA(rs.getString("MOTIVO_BAJA"));
p.setMarcaje(rs.getInt("MARCAJE"));
cnn.close();
ps.close();
return p;
// p.setId_Medida(rs.getInt("id_medida"));
//p.setId_Presentacion(rs.getInt("id_presentacion"));
}
} catch (Exception e) {
System.err.println("errroooooorrr"+e);
}
return null;
}
public static boolean DardeBajaEmpleado(ListaMaestro t) throws SQLException{
Connection cn = BD.getConnection();
PreparedStatement ps = null;
ps = cn.prepareStatement("UPDATE ALISTAEMPLEADOS SET FECHA_BAJA = ?,MOTIVO_BAJA = ?,ESTADO = 2,MARCAJE = 2 WHERE CODIGO ="+t.getCODIGO());
ps.setDate(1,new java.sql.Date(t.getFECHA_BAJA().getTime()));
ps.setString(2, t.getMOTIVO_BAJA());
int rowsUpdated = ps.executeUpdate();
cn.close();
ps.close();
if (rowsUpdated > 0) {
return true;
} else {
return false;
}
}
}
|
package filamentengine.content.organization;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import nu.xom.Element;
import nu.xom.Elements;
import filamentengine.content.Entity;
import filamentengine.io.xml.XMLSerializeable;
public class EntityManager implements XMLSerializeable {
private final HashMap<String, List<Entity>> entitiesByType;
private final List<Entity> entities;
public EntityManager() {
entitiesByType = new HashMap<String, List<Entity>>();
entities = new LinkedList<Entity>();
}
public void addEntity(final Entity entity) {
for (String type : entity.getTypeList()) {
if (!entitiesByType.containsKey(type)) {
entitiesByType.put(type, new LinkedList<Entity>());
}
entitiesByType.get(type).add(entity);
}
entities.add(entity);
}
public void removeEntity(final Entity entity) {
for (String type : entity.getTypeList()) {
if (entitiesByType.containsKey(type)) {
entitiesByType.get(type).remove(entity);
}
}
entities.remove(entity);
}
public List<Entity> getEntitiesByType(final String... types) {
List<Entity> en = new LinkedList<Entity>();
for (String type : types) {
if (entitiesByType.containsKey(type)) {
en.addAll(entitiesByType.get(type));
}
}
return en;
}
/**
* Return a shallow copy of the list of entities.
*
* @return shallow list copy
*/
public List<Entity> getAllEntities() {
return new LinkedList<Entity>(entities);
}
public void clearAllEntities() {
entities.clear();
entitiesByType.clear();
}
@Override
public Element writeToElement() {
Element ele = new Element(getElementName());
for (Entity ent : entities) {
ele.appendChild(ent.writeToElement());
}
return ele;
}
@Override
public void assembleFromElement(Element entity) {
clearAllEntities();
Elements ents = entity.getChildElements();
for (int i = 0; i < entity.getChildCount(); i++) {
Entity e = new Entity();
e.assembleFromElement(ents.get(i));
addEntity(e);
}
}
@Override
public String getElementName() {
return "entities";
}
}
|
/*
* Copyright Verizon Media, Licensed under the terms of the Apache License, Version 2.0. See LICENSE file in project root for terms.
*/
package com.yahoo.cubed.model;
import com.yahoo.cubed.json.filter.Filter;
import com.yahoo.cubed.model.filter.PipelineFilter;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.OneToMany;
import javax.persistence.FetchType;
import javax.persistence.Transient;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
import java.util.List;
import java.util.ArrayList;
import lombok.Getter;
import lombok.Setter;
/**
* The Funnel Group object.
*/
@Entity
@Table(name = "funnel_group")
public class FunnelGroup implements AbstractModel {
/** Funnel group ID. */
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "funnel_group_id", nullable = false)
@Getter @Setter
private long funnelGroupId;
/** Funnel group name. */
@Column(name = "funnel_group_name", nullable = false)
@Getter @Setter
private String funnelGroupName;
/** Product Name. */
@Column(name = "product_name")
@Getter @Setter
private String productName = "cubed";
/** Funnel group owner. */
@Column(name = "funnel_group_owner")
@Getter @Setter
private String funnelGroupOwner;
/** Funnel group description. */
@Column(name = "funnel_group_description")
@Getter @Setter
private String funnelGroupDescription;
/** A set of pipelines that the funnel group has. */
@Fetch(value = FetchMode.SELECT)
@OneToMany(mappedBy = "funnelGroupId", cascade = {}, fetch = FetchType.LAZY)
@Getter
private List<Pipeline> pipelines;
/** List of projections. All funnels in a funnel group should have same projections. */
@Fetch(value = FetchMode.SELECT)
@OneToMany(mappedBy = "funnelGroupId", cascade = {}, fetch = FetchType.LAZY)
@Getter
private List<PipelineProjection> projections;
/** Funnel group user id field. Same across all funnels in group. */
@Column(name = "funnel_group_user_id_field")
@Getter @Setter
private String funnelGroupUserIdField;
/** Funnel group repeat interval. Same across all funnels in group. */
@Column(name = "funnel_group_repeat_interval")
@Getter @Setter
private String funnelGroupRepeatInterval;
/** Funnel group query range. Same across all funnels in group. */
@Column(name = "funnel_group_query_range")
@Getter @Setter
private String funnelGroupQueryRange;
/*
* Funnel group step names.
* Step names are ordered by a graph traversal, from all in-degree = 0 nodes to all out-degree = 0 nodes.
* The sequence is unique. For nodes in the same level, sorting alphabetically.
*/
@Column(name = "funnel_group_step_names")
@Getter @Setter
private String funnelGroupStepNames;
/** Funnel group step JSONs. The same order as step names. */
@Column(name = "funnel_group_steps_json")
@Getter @Setter
private String funnelGroupStepsJson;
/** Funnel group oozie job id. */
@Column(name = "funnel_group_oozie_job_id")
@Getter @Setter
private String funnelGroupOozieJobId;
/** Funnel group oozie job status. */
@Column(name = "funnel_group_oozie_job_status")
@Getter @Setter
private String funnelGroupOozieJobStatus;
/** Funnel group deleted status. */
@Column(name = "funnel_group_is_deleted")
private boolean funnelGroupIsDeleted;
/*
* Funnel group create time.
* If this field value is null/empty, then there is no end time.
*/
@Column(name = "funnel_group_create_time")
@Getter @Setter
private String funnelGroupCreateTime;
/*
* Funnel group edit time.
* If this field value is null/empty, then there is no edit time.
*/
@Column(name = "funnel_group_edit_time")
@Getter @Setter
private String funnelGroupEditTime;
/*
* Funnel group end time.
* If this field value is null/empty, then there is no end time.
*/
@Column(name = "funnel_group_end_time")
@Getter @Setter
private String funnelGroupEndTime;
/*
* Funnel group backfill start time.
* If this field value is null/empty, it means no backfill.
*/
@Column(name = "funnel_group_backfill_start_time")
@Getter @Setter
private String funnelGroupBackfillStartTime;
/** Funnel group version. */
@Column(name = "funnel_group_version")
@Setter
private Long funnelGroupVersion;
/*
* Funnel group schema name.
* All funnels in the same group must have the same schema.
* However this restriction could be relaxed in future versions as long as aggregations are the same.
* But it introduces dev complexity.
*/
@Column(name = "funnel_group_schema_name")
@Getter @Setter
private String funnelGroupSchemaName;
/** Funnel group status. */
@Column(name = "funnel_group_status")
@Getter @Setter
private String funnelGroupStatus;
/** Funnel group filter JSON string. Same across all funnels in group. */
@Column(name = "funnel_group_filter_json")
@Getter @Setter
private String funnelGroupFilterJson;
/** Funnel group topology string. Used to reconstruct the graph. */
@Column(name = "funnel_group_topology")
@Getter @Setter
private String funnelGroupTopology;
/** User specified funnel names. */
@Column(name = "funnel_names")
@Getter @Setter
private String funnelNames;
/** Get filters. */
@Transient
public PipelineFilter funnelGroupFilterObject;
/**
* Get funnel group version.
*/
public long getFunnelGroupVersion() {
if (funnelGroupVersion == null) {
return 1L;
}
return this.funnelGroupVersion;
}
/**
* Set projections for the funnel group.
*/
public void setProjections(List<PipelineProjection> projections) {
for (PipelineProjection p : projections) {
p.setFunnelGroupId(this.funnelGroupId);
}
this.projections = projections;
}
/**
* Set pipelines for the funnel group.
*/
public void setPipelines(List<Pipeline> pipelines) {
for (Pipeline p : pipelines) {
p.setFunnelGroupId(this.funnelGroupId);
}
this.pipelines = pipelines;
}
/**
* Get funnel group filter object, transforming from json to filter object.
*/
public PipelineFilter getFunnelGroupFilterObject() {
if (funnelGroupFilterObject == null && funnelGroupFilterJson != null) {
try {
funnelGroupFilterObject = Filter.fromJson(funnelGroupFilterJson).toModel(funnelGroupSchemaName);
} catch (Exception e) {
return null;
}
}
return funnelGroupFilterObject;
}
/**
* Set funnel group filter.
*/
public void setFunnelGroupFilterObject(PipelineFilter pipelineFilterObject) {
this.funnelGroupFilterObject = pipelineFilterObject;
}
/**
* Check if funnel group backfill is enabled.
*/
public boolean isFunnelGroupBackfillEnabled() {
return funnelGroupBackfillStartTime != null && !funnelGroupBackfillStartTime.isEmpty();
}
/**
* Check if funnel group end time is enabled.
*/
public boolean isFunnelGroupEndTimeEnabled() {
return funnelGroupEndTime != null && !funnelGroupEndTime.isEmpty();
}
/**
* Set if funnel group should be marked as deleted.
*/
public void setFunnelGroupIsDeleted(boolean isFunnelGroupDeleted) {
this.funnelGroupIsDeleted = isFunnelGroupDeleted;
}
/**
* Check if funnel group is marked as deleted.
*/
public boolean getFunnelGroupIsDeleted() {
return funnelGroupIsDeleted;
}
/**
* Get funnel group id.
*/
public long getPrimaryIdx() {
return this.getFunnelGroupId();
}
/**
* Simplify pipeline.
*/
public FunnelGroup simplify() {
FunnelGroup newFunnelGroup = new FunnelGroup();
newFunnelGroup.funnelGroupId = this.funnelGroupId;
newFunnelGroup.funnelGroupName = this.funnelGroupName;
newFunnelGroup.productName = this.productName;
newFunnelGroup.funnelGroupOwner = this.funnelGroupOwner;
newFunnelGroup.funnelGroupDescription = this.funnelGroupDescription;
newFunnelGroup.funnelGroupFilterJson = this.funnelGroupFilterJson;
newFunnelGroup.funnelGroupUserIdField = this.funnelGroupUserIdField;
newFunnelGroup.funnelGroupRepeatInterval = this.funnelGroupRepeatInterval;
newFunnelGroup.funnelGroupQueryRange = this.funnelGroupQueryRange;
newFunnelGroup.funnelGroupStepNames = this.funnelGroupStepNames;
newFunnelGroup.funnelGroupStepsJson = this.funnelGroupStepsJson;
newFunnelGroup.funnelGroupOozieJobId = this.funnelGroupOozieJobId;
newFunnelGroup.funnelGroupOozieJobStatus = this.funnelGroupOozieJobStatus;
newFunnelGroup.funnelGroupIsDeleted = this.funnelGroupIsDeleted;
newFunnelGroup.funnelGroupCreateTime = this.funnelGroupCreateTime;
newFunnelGroup.funnelGroupEditTime = this.funnelGroupEditTime;
newFunnelGroup.funnelGroupEndTime = this.funnelGroupEndTime;
newFunnelGroup.funnelGroupBackfillStartTime = this.funnelGroupBackfillStartTime;
newFunnelGroup.funnelGroupVersion = this.funnelGroupVersion;
newFunnelGroup.funnelGroupSchemaName = this.funnelGroupSchemaName;
newFunnelGroup.funnelGroupStatus = this.funnelGroupStatus;
newFunnelGroup.funnelGroupTopology = this.funnelGroupTopology;
return newFunnelGroup;
}
/**
* Simplify list of funnel groups.
*/
public static List<FunnelGroup> simplifyFunnelGroupList(List<FunnelGroup> funnelGroups) {
if (funnelGroups == null) {
return null;
}
List<FunnelGroup> newFunnelGroups = new ArrayList<>();
for (FunnelGroup group : funnelGroups) {
newFunnelGroups.add(group.simplify());
}
return newFunnelGroups;
}
/**
* Get pipeline name.
*/
@Override
public String getPrimaryName() {
return this.getFunnelGroupName();
}
}
|
package com.esum.wp.ims.batchinstancelog.struts.action;
import java.util.TimeZone;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import com.esum.appcommon.resource.application.Config;
import com.esum.appcommon.session.SessionMgr;
import com.esum.appframework.struts.action.BaseDelegateAction;
import com.esum.appframework.struts.actionform.BeanUtilForm;
import com.esum.imsutil.util.DateUtil;
import com.esum.wp.ims.batchinfo.BatchInfo;
import com.esum.wp.ims.batchinstancelog.BatchInstanceLog;
public class BatchInstanceLogAction extends BaseDelegateAction {
protected ActionForward doService(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
if (method.equals("selectList")) {
BatchInstanceLog batchInstanceLog = null;
BeanUtilForm beanUtilForm = (BeanUtilForm)form;
request.removeAttribute("inputObject");
request.removeAttribute("outputObject");
Object inputObject = null;
if (beanUtilForm != null) {
inputObject = beanUtilForm.getBean();
}else {
beanUtilForm = new BeanUtilForm();
}
int itemCountPerPage = Config.getInt("Common", "LIST.COUNT_PER_PAGE");
if(inputObject == null) {
batchInstanceLog = new BatchInstanceLog();
batchInstanceLog.setCurrentPage(new Integer(1));
batchInstanceLog.setItemCountPerPage(new Integer(itemCountPerPage));
}else {
batchInstanceLog = (BatchInstanceLog)inputObject;
if(batchInstanceLog.getCurrentPage() == null) {
batchInstanceLog.setCurrentPage(new Integer(1));
}
if(batchInstanceLog.getItemCountPerPage() == null) {
batchInstanceLog.setItemCountPerPage(new Integer(itemCountPerPage));
}
}
//db
SessionMgr sessMgr = new SessionMgr(request);
batchInstanceLog.setDbType(sessMgr.getValue("dbType"));
//timezone 계산
TimeZone serverTz = TimeZone.getTimeZone(Config.getString("Common","DB.TIMEZONE"));
String ctimezoneT = StringUtils.isEmpty(sessMgr.getValue("ctimezone")) ? "0" : sessMgr.getValue("ctimezone");
int ctimezone = Integer.parseInt(ctimezoneT);
TimeZone clientTz = TimeZone.getTimeZone(ctimezone>=0?"GMT+"+ctimezone:"GMT"+ctimezone);
//fromDateTime
String clntFromDateTime = batchInstanceLog.getFromdate() + batchInstanceLog.getFromtime();
if(StringUtils.isNotEmpty(clntFromDateTime))
batchInstanceLog.setStartDate(DateUtil.getDateString("yyyyMMddHHmm", clntFromDateTime, clientTz, "yyyyMMddHHmm", serverTz));
//toDateTime
String clntToDateTime = batchInstanceLog.getTodate() + batchInstanceLog.getTotime();
if(StringUtils.isNotEmpty(clntToDateTime))
batchInstanceLog.setEndDate(DateUtil.getDateString("yyyyMMddHHmm", clntToDateTime, clientTz, "yyyyMMddHHmm", serverTz));
beanUtilForm.setBean(batchInstanceLog);
request.setAttribute("inputObject", batchInstanceLog);
return super.doService(mapping, beanUtilForm, request, response);
} else if (method.equals("select")) {
BatchInstanceLog batchInstanceLog = null;
BeanUtilForm beanUtilForm = (BeanUtilForm)form;
request.removeAttribute("inputObject");
request.removeAttribute("outputObject");
Object inputObject = null;
if (beanUtilForm != null) {
inputObject = beanUtilForm.getBean();
}else {
beanUtilForm = new BeanUtilForm();
}
if(inputObject == null) {
batchInstanceLog = new BatchInstanceLog();
}else {
batchInstanceLog = (BatchInstanceLog)inputObject;
}
beanUtilForm.setBean(batchInstanceLog);
request.setAttribute("inputObject", batchInstanceLog);
request.setAttribute("outputObject", new BatchInfo());
return super.doService(mapping, beanUtilForm, request, response);
}else {
return super.doService(mapping, form, request, response);
}
}
}
|
package com.memberComment.model;
import java.sql.Date;
import com.emp.model.EmpVO;
public class MemberCommentVO {
private String memberCommentId;
private String memberAId;
private String memberBId;
private String memberCommentContent;
private Double memberCommentLevel;
private java.sql.Date memberCommentDate;
private String memberCommStatus;
private String memberCommStatusEmp;
private String memberCommStatusComm;
public static class Builder {
private String memberCommentId = "";
private String memberAId = "";
private String memberBId = "";
private String memberCommentContent = "";
private Double memberCommentLevel = 0.0;
private java.sql.Date memberCommentDate = (new java.sql.Date(System.currentTimeMillis()));
private String memberCommStatus = "";
private String memberCommStatusEmp = "";
private String memberCommStatusComm = "";
public MemberCommentVO.Builder memberCommentId(String memberCommentId) {
this.memberCommentId = memberCommentId;
return this;
}
public MemberCommentVO.Builder memberAId(String memberAId) {
this.memberAId = memberAId;
return this;
}
public MemberCommentVO.Builder memberBId(String memberBId) {
this.memberBId = memberBId;
return this;
}
public MemberCommentVO.Builder memberCommentContent(String memberCommentContent) {
this.memberCommentContent = memberCommentContent;
return this;
}
public MemberCommentVO.Builder memberCommentLevel(Double memberCommentLevel) {
this.memberCommentLevel = memberCommentLevel;
return this;
}
public MemberCommentVO.Builder memberCommentDate(java.sql.Date memberCommentDate) {
this.memberCommentDate = memberCommentDate;
return this;
}
public MemberCommentVO.Builder memberCommStatus(String memberCommStatus) {
this.memberCommStatus = memberCommStatus;
return this;
}
public MemberCommentVO.Builder memberCommStatusEmp(String memberCommStatusEmp) {
this.memberCommStatusEmp = memberCommStatusEmp;
return this;
}
public MemberCommentVO.Builder memberCommStatusComm(String memberCommStatusComm) {
this.memberCommStatusComm = memberCommStatusComm;
return this;
}
}
public MemberCommentVO() {
super();
}
private MemberCommentVO(MemberCommentVO.Builder builder) {
memberCommentId = builder.memberCommentId;
memberAId = builder.memberAId;
memberBId = builder.memberBId;
memberCommentContent = builder.memberCommentContent;
memberCommentLevel = builder.memberCommentLevel;
memberCommentDate = builder.memberCommentDate;
memberCommStatus = builder.memberCommStatus;
memberCommStatusEmp = builder.memberCommStatusEmp;
memberCommStatusComm = builder.memberCommStatusComm;
}
public String getMemberCommentId() {
return memberCommentId;
}
public void setMemberCommentId(String memberCommentId) {
this.memberCommentId = memberCommentId;
}
public String getMemberAId() {
return memberAId;
}
public void setMemberAId(String memberAId) {
this.memberAId = memberAId;
}
public String getMemberBId() {
return memberBId;
}
public void setMemberBId(String memberBId) {
this.memberBId = memberBId;
}
public String getMemberCommentContent() {
return memberCommentContent;
}
public void setMemberCommentContent(String memberCommentContent) {
this.memberCommentContent = memberCommentContent;
}
public Double getMemberCommentLevel() {
return memberCommentLevel;
}
public void setMemberCommentLevel(Double memberCommentLevel) {
this.memberCommentLevel = memberCommentLevel;
}
public java.sql.Date getMemberCommentDate() {
return memberCommentDate;
}
public void setMemberCommentDate(java.sql.Date memberCommentDate) {
this.memberCommentDate = memberCommentDate;
}
public String getMemberCommStatus() {
return memberCommStatus;
}
public void setMemberCommStatus(String memberCommStatus) {
this.memberCommStatus = memberCommStatus;
}
public String getMemberCommStatusEmp() {
return memberCommStatusEmp;
}
public void setMemberCommStatusEmp(String memberCommStatusEmp) {
this.memberCommStatusEmp = memberCommStatusEmp;
}
public String getMemberCommStatusComm() {
return memberCommStatusComm;
}
public void setMemberCommStatusComm(String memberCommStatusComm) {
this.memberCommStatusComm = memberCommStatusComm;
}
@Override
public String toString() {
return "MemberCommentVO [memberCommentId=" + memberCommentId + ", memberAId=" + memberAId + ", memberBId=" + memberBId
+ ", memberCommentContent=" + memberCommentContent + ", memberCommentLevel=" + memberCommentLevel
+ ", memberCommentDate=" + memberCommentDate + ", memberCommStatus=" + memberCommStatus
+ ", memberCommStatusEmp=" + memberCommStatusEmp + ", memberCommStatusComm=" + memberCommStatusComm
+ "]";
}
}
|
package io.github.ihongs.serv.centre;
import io.github.ihongs.CoreConfig;
import io.github.ihongs.HongsException;
import io.github.ihongs.action.ActionHelper;
import io.github.ihongs.action.anno.Action;
import io.github.ihongs.action.anno.CommitSuccess;
import io.github.ihongs.action.anno.Verify;
import io.github.ihongs.db.DB;
import io.github.ihongs.serv.auth.AuthKit;
import io.github.ihongs.serv.master.User;
import io.github.ihongs.util.Synt;
import java.util.HashMap;
import java.util.Map;
/**
* 登录动作
* @author Hongs
*/
@Action("centre/sign")
public class SignAction extends io.github.ihongs.serv.centra.SignAction {
/**
* 登录
* @param ah
* @throws HongsException
*/
@Action("create")
@Verify(conf="master", form="sign")
@CommitSuccess
@Override
public void signCreate(ActionHelper ah) throws HongsException {
CoreConfig cc = CoreConfig.getInstance("master");
if(!cc.getProperty("core.public.sign.open",true)) {
throw new HongsException(404,"Sign in is not allowed");
}
super.signCreate(ah);
}
/**
* 注册
* @param ah
* @throws HongsException
*/
@Action("user/create")
@Verify(conf="master", form="regs", type=0, trim=1)
@CommitSuccess
public void userCreate(ActionHelper ah) throws HongsException {
CoreConfig cc = CoreConfig.getInstance("master");
if(!cc.getProperty("core.public.regs.open",true)) {
throw new HongsException(404,"Sign on is not allowed");
}
User uo = (User) DB.getInstance("master").getModel("user");
Map rd = ah.getRequestData();
String uuid = uo.create(rd);
String uname = Synt.declare(rd.get("name"), "");
String uhead = Synt.declare(rd.get("head"), "");
// 加入公共部门
Map sd = new HashMap();
sd.put("user_id", uuid);
sd.put("dept_id", cc.getProperty("core.public.regs.dept", "CENTRE"));
uo.db.getTable("dept_user").insert(sd);
// 赋予公共权限. 仅用部门即可(2019/02/28)
// Map sd = new HashMap();
// sd.put("user_id", uuid);
// sd.put("role" , cc.getProperty("core.public.regs.role", "centre"));
// uo.db.getTable("user_role").insert(sd);
ah.reply(AuthKit.userSign(ah, uuid, uname, uhead));
}
/**
* 查重
* @param ah
* @throws HongsException
*/
@Action("user/unique")
public void userUnique(ActionHelper ah) throws HongsException {
User uo = (User) DB.getInstance("master").getModel("user");
Map rd = ah.getRequestData();
boolean v = uo.unique ( rd );
ah.reply ( null, v ? 1 : 0 );
}
}
|
package pages;
import org.openqa.selenium.By;
import org.openqa.selenium.support.ui.Select;
import driverFactory.CustomWebDriver;
public class LogPaymentAnalysisPage extends BasePage {
private String listLocatorString = "//div[@class='dhx_combo_list']/div[contains(translate(.,'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ'), '<val>')][1]";
private By riskDdlLocator = By.id("CLM_SC_BO_0111_Risk_50a");
private By coverageFeatureDdlLocator = By.id("CLM_SC_BO_0111_CoverageCombined_50a");
private String coverageFeaturelistLocatorString = "//div[@class='dhx_combo_list']/div[contains(.,'<val>')][1]";
private By reserveDdlLocator = By.id("CLM_SC_BO_0111_ReserveType_50a");
private String paymentCodelistLocatorString = "//*[@id='CLM_SC_BO_0111_PaymentCode_50a']/option[contains(.,'<val>')][1]";
private By amountTxtBoxLocator = By.id("CLM_SC_BO_0111_Amount_50a");
private By deductibleTxtBoxLocator = By.id("CLM_SC_BO_0111_DeductibleApplied_50a");
private By paymentTypeDdlLocator = By.id("CLM_SC_BO_0111_PaymentType_50a");
private By addBtnLocator = By.id("CLM_SC_BO_0111_LinePaymentAdd_50a");
public void selectRiskAddress(String riskAddress) {
writeStepToTestNGReport("Select risk address from Risk dropdown");
driver.get().findElement(riskDdlLocator).click();
driver.get().findElement(By.xpath(listLocatorString.replace("<val>", riskAddress.toUpperCase()))).click();
progressSync();
}
public void selectCoverageFeature(String cvrgDdlVal) {
writeStepToTestNGReport("Select coverage feature");
driver.get().findElement(coverageFeatureDdlLocator).click();
driver.get().findElement(By.xpath(coverageFeaturelistLocatorString.replace("<val>", cvrgDdlVal))).click();
sleep(2);
acceptAlert();
progressSync();
acceptAlert();
}
public void selectReserve(String reserveType) {
writeStepToTestNGReport("Select reserve type");
new Select(driver.get().findElement(reserveDdlLocator)).selectByVisibleText(reserveType);
sleep(2);
acceptAlert();
sleep(2);
progressSync();
acceptAlert();
}
public void selectPaymentCode(String paymentCode) {
writeStepToTestNGReport("Select payment code");
driver.get().findElement(By.xpath(paymentCodelistLocatorString.replace("<val>", paymentCode))).click();
}
public void enterPayAmount(String payAmount) {
writeStepToTestNGReport("Enter amount");
driver.get().findElement(amountTxtBoxLocator).sendKeys(payAmount);
}
public void enterDeductible(String deductibleAmount) {
writeStepToTestNGReport("Enter deductible");
if (existsElement(deductibleTxtBoxLocator)) {
if (driver.get().findElement(deductibleTxtBoxLocator).isEnabled()) {
driver.get().findElement(deductibleTxtBoxLocator).sendKeys(deductibleAmount);
}
}
}
public void selectPaymentType(String paymentType) {
writeStepToTestNGReport("Select payment type");
new Select(driver.get().findElement(paymentTypeDdlLocator)).selectByVisibleText(paymentType);
}
public void clickAddBtn() {
writeStepToTestNGReport("Click Add button");
driver.get().findElement(addBtnLocator).click();
progressSync();
}
public void fillPaymentAnalysisData(String riskAddressWithCommas,
String cvrgDdlVal, String reserveType, String paymentCode,
String payAmount, String deductibleAmount, String paymentType) {
// Auto-generated method stub
selectRiskAddress(riskAddressWithCommas);
selectCoverageFeature(cvrgDdlVal);
selectReserve(reserveType);
selectPaymentCode(paymentCode);
enterPayAmount(payAmount);
enterDeductible(deductibleAmount);
selectPaymentType(paymentType);
clickAddBtn();
clickFlowNext();
}
}
|
package a1;
public class Model {
private float y = 0.0f;
private float incY = 0.01f;
private float x = 0.0f;
private float size = 0.0f;
private float sizeInc = 0.01f;
private boolean isMoving = false;
private boolean isRotating = false;
private float gradient = 1.0f;
/**
* Updates the value of x and y if isMoving or isRotating is true.
*/
public void update(){
move();
rotate();
}
/**
* If isMoving is true each vertex moves up till it reaches the top then down till it reaches the bottom.
* Then it repeats.
*/
public void move(){
if(isMoving()) {
y += incY;
if (y >= 1.0f) { incY = -0.01f;}
if (y <= -1.0f) { incY = 0.01f;}
}
}
/**
* If isRotating is true the vertices are rotated around the origin.
*/
public void rotate(){
if(isRotating()){
double tempX = x * Math.cos(0.1) - y * Math.sin(0.1);
double tempY = y * Math.cos(0.1) + x * Math.sin(0.1);
x = (float)tempX;
y = (float)tempY;
}
}
/**
* If the input is pos increase the size by sizeInc, if neg decrease the size by sizeInc.
* @param i float input from the mouse wheel.
*/
public void changeSize(float i){
if(i > 0){
size = size + sizeInc;
}
if(i < 0 && size > -0.25f){
size = size - sizeInc;
}
}
/**
* Returns the size offset for the vertices.
* @return float size
*/
public float getSize(){
return this.size;
}
/**
* Returns the y offset for the vertices.
* @return float y
*/
public float getY(){
return this.y;
}
/**
* Returns the x offset for the vertices.
* @return float x
*/
public float getX(){
return this.x;
}
/**
* Returns if the move button has been selected.
* @return boolean isMoving.
*/
public boolean isMoving() {
return isMoving;
}
/**
* Sets the value of isMoving to moving.
* @param moving boolean
*/
public void setMoving(boolean moving) {
isMoving = moving;
}
/**
* Returns if the rotate button has been selected.
* @return boolean isRotating.
*/
public boolean isRotating(){
return isRotating;
}
/**
* Sets the value of isRotating to rotating.
* @param rotating boolean
*/
public void setRotating(boolean rotating){
isRotating = rotating;
}
/**
* Flips the value of gradient from 0.0 to 1.0. Must me a float because it
* needs to be sent to the shader code.
*/
public void flipGradient(){
if(gradient == 0.0f){gradient = 1.0f;}
else gradient = 0.0f;
}
/**
* Returns the value of gradient.
* @return float gradient
*/
public float getGradient(){
return gradient;
}
}
|
package day4;
import java.util.Iterator;
import java.util.PriorityQueue;
public class PriorityQueueExample {
public static void main(String[] args) {
PriorityQueue<Integer> que = new PriorityQueue<Integer>();
que.add(10);
que.add(200);
que.add(180);
que.add(350);
que.add(154);
System.out.println("Head: "+que.element()); //prints the top element in queue
System.out.println("Head: "+que.peek());
System.out.println("---------------------------------------------------------");
Iterator<Integer> itr = que.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
que.remove();// This removes the first element from queue
que.poll();// This removes the first element from queue
System.out.println("---------------------------------------------------------");
System.out.println("After removing two elements from queue:");
itr = que.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
}
}
|
import java.util.Scanner;
import java.util.Arrays;
import java.util.Random;
public class MakingSdocu {
public static void main(String[] args) {
System.out.println("정수을 입력하시오.");
Scanner nu = new Scanner(System.in);
int n = nu.nextInt();
int temp[][] = new int[n][n];
int i;
int j;
int num[][] = new int[n][n];
int change = num.length;
for (i = 0; i < num.length; i++) {
for (j = 0; j < num[i].length; j++) {
num[i][j] = (i + j) % n + 1;
}
}
for (int a = 0; a < change; a++) {
int r = (int) (Math.random() * change);
int r2 = (int) (Math.random() * change);
for (int b = 0; b < change; b++) {
temp[0][b] = num[r][b];
num[r][b] = num[r2][b];
num[r2][b] = temp[0][b];
}
}
for (int a = 0; a < change; a++) {
int r = (int) (Math.random() * change);
int r2 = (int) (Math.random() * change);
for (int b = 0; b < change; b++) {
temp[b][0] = num[b][r];
num[b][r] = num[b][r2];
num[b][r2] = temp[b][0];
}
}
for (i = 0; i < num.length; i++) {
for (j = 0; j < num[i].length; j++) {
System.out.print(num[i][j] + " ");
}
System.out.println();
}
}
} |
package me.k11i.rng;
import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
public class AliasMethod {
private final int n;
private final double[] prob;
private final int[] alias;
AliasMethod(int[] weights) {
this(IntStream.of(weights).asDoubleStream().toArray());
}
AliasMethod(double[] weights) {
n = weights.length;
prob = new double[n];
alias = new int[n];
double totalWeight = DoubleStream.of(weights).sum();
double[] p = DoubleStream.of(weights).map(w -> w / totalWeight).toArray();
double mean = 1.0 / n;
int[] work = new int[n];
int s = 0, l = n;
for (int i = 0; i < n; i++) {
work[p[i] > mean ? --l : s++] = i;
}
while (s != 0 && l != n) {
int si = work[--s], li = work[l++];
prob[si] = n * p[si];
alias[si] = li;
p[li] += (p[si] - mean);
if (p[li] > mean) {
work[--l] = li;
} else {
work[s++] = li;
}
}
while (s > 0) {
prob[work[--s]] = 1;
}
while (l < n) {
prob[work[l++]] = 1;
}
}
int roll(Random r) {
int i = r.nextInt(n);
if (r.nextDouble() < prob[i]) {
return i;
} else {
return alias[i];
}
}
}
|
package com.example.johann.santa;
import android.os.Parcel;
import android.os.Parcelable;
public class Enfant implements Parcelable {
private String _sexe;
private String _prenom;
private String _annee_naissance;
@SuppressWarnings("rawtypes")
public static final Parcelable.Creator CREATOR = new CreatorImplementation();
//Regular constructor
public Enfant(String sexe, String prenom, String annee) {
super();
this._sexe = sexe;
this._prenom = prenom;
this._annee_naissance = annee;
}
//Constructor from parcel
public Enfant(Parcel in) {
super();
this._sexe = in.readString();
this._prenom = in.readString();
this._annee_naissance = in.readString();
}
public void setNom(String sexe) {
this._sexe = sexe;
}
public void setPrenom(String prenom) {
this._prenom = prenom;
}
public void set_annee_naissance(String annee_naissance) {
this._prenom = annee_naissance;
}
public String getSexe() {
return this._sexe;
}
public String getPrenom() {
return this._prenom;
}
public String get_annee_naissance() {
return this._annee_naissance;
}
@Override
public int describeContents() { return 0; }
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(this._sexe);
dest.writeString(this._prenom);
dest.writeString(this._annee_naissance);
}
@SuppressWarnings("rawtypes")
private static final class CreatorImplementation implements Parcelable.Creator {
public Enfant createFromParcel(Parcel in) {
return new Enfant(in);
}
@Override
public Object[] newArray(int size) {
// TODO Auto-generated method stub
return null;
}
}
} |
package fr.eni.groupe2.servlets;
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 javax.servlet.http.HttpSession;
import fr.eni.groupe2.bll.UtilisateurManager;
import fr.eni.groupe2.bo.Utilisateur;
import fr.eni.groupe2.messages.BusinessException;
import fr.eni.groupe2.messages.DALException;
/**
*
* @author groupe 2
* @projet ENI ENCHERES AVRIL 2021
* @description La servlet inscription permet de convertir les données de l'utilisateur en
* un objet de type utilisateur et permet l'enregistrement de celui-ci en base.
*
*
*
*/
@WebServlet(name ="Inscritption" ,
urlPatterns=("/Inscription"))
public class Inscription extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.getServletContext().getRequestDispatcher("/WEB-INF/Inscription.jsp").forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Utilisateur utilisateur = new Utilisateur();
String errorMessage = "";
try {
utilisateur.setPseudo(request.getParameter("pseudo").toLowerCase());
utilisateur.setNom(request.getParameter("nom").toLowerCase());
utilisateur.setPrenom(request.getParameter("prenom").toLowerCase());
utilisateur.setEmail(request.getParameter("email").toLowerCase());
utilisateur.setTelephone(request.getParameter("telephone").toLowerCase());
utilisateur.setRue(request.getParameter("rue").toLowerCase());
utilisateur.setCodePostal(request.getParameter("codePostal").toLowerCase());
utilisateur.setVille(request.getParameter("ville").toLowerCase());
utilisateur.setCredit(0);
utilisateur.setAdministrateur(false);
if (request.getParameter("motDePasse").equals(request.getParameter("confirmation"))) {
utilisateur.setMotDePasse(request.getParameter("motDePasse"));
boolean ok = UtilisateurManager.ajouterUtilisateur(utilisateur);
if (!ok) {
errorMessage = "l'utilisateur existe deja!( pseudo , nom, email identique) ";
request.setAttribute("errorMessage", errorMessage);
} else {
// je retourne un msg pour dire que l'inscription est ok
request.setAttribute("etatInscription", "inscription ok");
}
} else {
errorMessage = "Les mots de passe sont différents !";
request.setAttribute("errorMessage", errorMessage);
}
} catch (BusinessException | DALException e) {
errorMessage = e.getMessage();
request.setAttribute("errorMessage", errorMessage);
}
if (errorMessage.isEmpty()) {
HttpSession session = request.getSession();
session.setAttribute("utilisateurConnecter", utilisateur);
// revoir la redirection vers /WEB-INF/Home.jsp mais pour les test je garde
this.getServletContext().getRequestDispatcher("/WEB-INF/Inscription.jsp").forward(request, response);
}else {
this.getServletContext().getRequestDispatcher("/WEB-INF/Inscription.jsp").forward(request, response);
}
}
}
|
package com.openfarmanager.android.utils;
import android.annotation.TargetApi;
import android.content.UriPermission;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.DocumentsContract;
import com.openfarmanager.android.App;
import com.openfarmanager.android.filesystem.FileSystemScanner;
import com.openfarmanager.android.model.exeptions.SdcardPermissionException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.OutputStream;
import java.util.List;
/**
* @author Vlad Namashko
*/
public class StorageUtils {
private static File sSdCard;
private static String sSdPath;
static {
sSdCard = Environment.getExternalStorageDirectory();
sSdPath = sSdCard != null ? sSdCard.getPath() : FileSystemScanner.ROOT;
}
public static File getSdCard() {
return sSdCard;
}
public static String getSdPath() {
return sSdPath;
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Uri checkForPermissionAndGetBaseUri() {
List<UriPermission> persistedUriPermissions = App.sInstance.getContentResolver().getPersistedUriPermissions();
if (persistedUriPermissions != null && persistedUriPermissions.size() > 0 && persistedUriPermissions.get(0).isWritePermission()) {
UriPermission permission = persistedUriPermissions.get(0);
return permission.getUri();
} else {
throw new SdcardPermissionException();
}
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Uri getDestinationFileUri(Uri uri, String sdCardPath, String currentPath) {
return getDestinationFileUri(uri, sdCardPath, currentPath, true);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Uri getDestinationFileUri(Uri uri, String sdCardPath, String currentPath, boolean appendFileName) {
if (!appendFileName) {
currentPath = currentPath.substring(0, currentPath.lastIndexOf(File.separator));
}
String subDir = currentPath.substring(sdCardPath.length());
if (subDir.startsWith(File.separator)) {
subDir = subDir.substring(1);
}
return DocumentsContract.buildDocumentUriUsingTree(uri,
DocumentsContract.getTreeDocumentId(Uri.parse(uri.getEncodedPath() +
subDir.replace("/", "%2F").replace(":", "%3A").replace(" ", "%20"))));
}
public static boolean checkVersion() {
return Build.VERSION.SDK_INT >= 21;
}
public static boolean checkUseStorageApi(String sdCardPath) {
return !Extensions.isNullOrEmpty(sdCardPath) && checkVersion();
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static OutputStream getStorageOutputFileStream(File destination, String sdCardPath) throws FileNotFoundException {
Uri baseUri = checkForPermissionAndGetBaseUri();
return getStorageOutputFileStream(destination, baseUri, sdCardPath);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static OutputStream getStorageOutputFileStream(File destination, Uri baseUri, String sdCardPath) throws FileNotFoundException {
String originalName = destination.getName();
String newName = destination.getName().replace(":", "_");
String destinationFile = destination.getAbsolutePath().replace(originalName, newName);
Uri outputFileUri = getDestinationFileUri(baseUri, sdCardPath, destinationFile, false);
if (!destination.exists()) {
DocumentsContract.createDocument(App.sInstance.getContentResolver(),
outputFileUri, "",
newName);
}
return App.sInstance.getContentResolver().openOutputStream(
getDestinationFileUri(baseUri, sdCardPath, destinationFile));
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean createNewFile(File destinationFile, String sdCardPath) {
if (!destinationFile.exists()) {
Uri outputFileUri = getDestinationFileUri(checkForPermissionAndGetBaseUri(),
sdCardPath, destinationFile.getAbsolutePath(), false);
return DocumentsContract.createDocument(App.sInstance.getContentResolver(),
outputFileUri, "",
destinationFile.getName()) != null;
}
return true;
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean mkDir(Uri baseUri, String sdCardPath, File outputDir) {
// ensure that parent path exists.
File parentFile = outputDir.getParentFile();
while (parentFile != null && !parentFile.exists()) {
mkDir(baseUri, sdCardPath, parentFile);
}
return DocumentsContract.createDocument(App.sInstance.getContentResolver(),
getDestinationFileUri(baseUri, sdCardPath, outputDir.getAbsolutePath(), false),
DocumentsContract.Document.MIME_TYPE_DIR, outputDir.getName()) != null;
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean delete(Uri baseUri, String sdCardPath, String path) {
return DocumentsContract.deleteDocument(App.sInstance.getContentResolver(),
StorageUtils.getDestinationFileUri(baseUri, sdCardPath, path));
}
}
|
package com.cl.earosb.iipzs.models;
/**
* Objeto para manejar mesajes desde la API
* Created by earosb on 30-10-15.
*/
public class Message {
private boolean error;
private String msg;
private User user;
public Message(boolean error, String msg, User user) {
this.error = error;
this.msg = msg;
this.user = user;
}
public boolean isError() {
return error;
}
public void setError(boolean error) {
this.error = error;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
|
package com.infoworks.lab.rest.models.events;
import com.infoworks.lab.rest.models.Message;
import com.it.soul.lab.sql.entity.Entity;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Map;
import java.util.Objects;
public class Event extends Entity implements Externalizable {
private String uuid;
private String timestamp;
private EventType eventType;
public EventType getEventType() {
return eventType;
}
public Event setEventType(EventType eventType) {
this.eventType = eventType;
return this;
}
public String getUuid() {
return uuid;
}
public Event setUuid(String uuid) {
this.uuid = uuid;
return this;
}
public String getTimestamp() {
return timestamp;
}
public Event setTimestamp(String timestamp) {
this.timestamp = timestamp;
return this;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(marshallingToMap(true));
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
Map<String, Object> data = (Map<String, Object>) in.readObject();
unmarshallingFromMap(data, true);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Event event = (Event) o;
return Objects.equals(uuid, event.uuid) &&
Objects.equals(timestamp, event.timestamp);
}
@Override
public int hashCode() {
return Objects.hash(uuid, timestamp);
}
@Override
public String toString() {
try {
return Message.marshal(this);
} catch (IOException e) {
e.printStackTrace();
}
return super.toString();
}
}
|
package biNumbers;
public class BiNumbersRunner {
public static void main(String[] args) {
// TODO Auto-generated method stub
BiNumbers numbers = new BiNumbers(2, 3);
System.out.println(numbers.add());// 2 + 3
System.out.println(numbers.multiply()); // 2 * 3
numbers.doubleValue();
System.out.println(numbers.getNumber1());// 4
System.out.println(numbers.getNumber2());// 6
}
}
|
package services;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import repositories.SearchTemplateRepository;
import domain.Chorbi;
import domain.Configuration;
import domain.SearchTemplate;
@Service
@Transactional
public class SearchTemplateService {
// Managed repository -----------------------------------------------------
@Autowired
private SearchTemplateRepository searchTemplateRepository;
// Supporting services ----------------------------------------------------
@Autowired
private ChorbiService chorbiService;
@Autowired
private CreditCardService creditCardService;
@Autowired
private ConfigurationService configurationService;
// Constructors -----------------------------------------------------------
public SearchTemplateService() {
super();
}
// Simple CRUD methods ----------------------------------------------------
public SearchTemplate findOne(final int searchTemplateId) {
Assert.isTrue(searchTemplateId != 0);
SearchTemplate result;
result = this.searchTemplateRepository.findOne(searchTemplateId);
return result;
}
public Collection<SearchTemplate> findAll() {
Collection<SearchTemplate> result;
result = this.searchTemplateRepository.findAll();
return result;
}
public SearchTemplate create(final Chorbi chorbi) {
Collection<Chorbi> results;
final SearchTemplate searchTemplate = new SearchTemplate();
results = new ArrayList<Chorbi>();
searchTemplate.setRelationshipType(null);
searchTemplate.setApproximateAge(null);
searchTemplate.setSingleKeyword(null);
searchTemplate.setGenre(null);
searchTemplate.setSearchTime(null);
searchTemplate.setCountry(null);
searchTemplate.setState(null);
searchTemplate.setProvince(null);
searchTemplate.setCity(null);
searchTemplate.setResults(results);
searchTemplate.setChorbi(chorbi);
return searchTemplate;
}
public SearchTemplate save(SearchTemplate searchTemplate) {
Assert.notNull(searchTemplate);
if (searchTemplate.getId() != 0)
Assert.isTrue(searchTemplate.getChorbi().equals(this.chorbiService.findByPrincipal()));
if (searchTemplate.getSingleKeyword() == "")
searchTemplate.setSingleKeyword(null);
if (searchTemplate.getCountry() == "")
searchTemplate.setCountry(null);
if (searchTemplate.getState() == "")
searchTemplate.setState(null);
if (searchTemplate.getProvince() == "")
searchTemplate.setProvince(null);
if (searchTemplate.getCity() == "")
searchTemplate.setCity(null);
searchTemplate.setSearchTime(null);
searchTemplate.getResults().clear();
searchTemplate = this.searchTemplateRepository.save(searchTemplate);
return searchTemplate;
}
public void delete(final SearchTemplate searchTemplate) {
Assert.notNull(searchTemplate);
Chorbi principal;
principal = this.chorbiService.findByPrincipal();
Assert.isTrue(principal.equals(searchTemplate.getChorbi()));
this.searchTemplateRepository.delete(searchTemplate);
}
// Other business methods -------------------------------------------------
public SearchTemplate findByChorbiId(final Chorbi chorbi) {
Assert.notNull(chorbi);
SearchTemplate result;
result = this.searchTemplateRepository.findByChorbiId(chorbi.getId());
return result;
}
public Collection<Chorbi> findChorbiesBySearchTemplate(SearchTemplate searchTemplate) {
Collection<Chorbi> result = new ArrayList<Chorbi>();
Calendar calendar;
Chorbi chorbi;
calendar = Calendar.getInstance();
calendar.set(Calendar.MILLISECOND, -10);
chorbi = this.chorbiService.findByPrincipal();
// primero: comprobar que tiene creditCard y que es valida
Assert.isTrue(this.creditCardService.checkValidation(this.creditCardService.findByActor(chorbi.getId())));
// segundo: comprobar la fecha en que se hizo la busqueda
if (searchTemplate.getSearchTime() == null) {
result = this.chorbiService.findNotBannedBySearchTemplate(searchTemplate);
searchTemplate.setSearchTime(calendar.getTime());
searchTemplate.setResults(result);
} else {
Calendar searchTimeCalendar;
Configuration configuration;
Calendar configurationCalendar;
searchTimeCalendar = Calendar.getInstance();
configurationCalendar = Calendar.getInstance();
configuration = this.configurationService.findConfiguration();
configurationCalendar.setTime(configuration.getCachedTime());
searchTimeCalendar.setTime(searchTemplate.getSearchTime());
searchTimeCalendar.add(Calendar.HOUR_OF_DAY, configurationCalendar.get(Calendar.HOUR_OF_DAY));
searchTimeCalendar.add(Calendar.MINUTE, configurationCalendar.get(Calendar.MINUTE));
searchTimeCalendar.add(Calendar.SECOND, configurationCalendar.get(Calendar.SECOND));
if (calendar.getTime().before(searchTimeCalendar.getTime()) || calendar.getTime().equals(searchTimeCalendar.getTime()))
// si la fecha actual es menor o igual que la fecha de busqueda mas cachedTime: devolver los resultados almacenados
result = searchTemplate.getResults();
else {
// si hace mas tiempo: hacer la busqueda de nuevo
result = this.chorbiService.findNotBannedBySearchTemplate(searchTemplate);
searchTemplate.setSearchTime(calendar.getTime());
searchTemplate.setResults(result);
}
}
searchTemplate = this.searchTemplateRepository.save(searchTemplate);
return result;
}
}
|
package com.boku.auth.http.keyprovider;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableEntryException;
import java.security.cert.CertificateException;
import java.security.spec.InvalidKeySpecException;
/**
* Implements {@link KeyProvider} by looking up the requested keys as passwords stored in a Java KeyStore.<br>
* Loading from PKCS12 files is supported, other formats may or may not work.<br>
* <br>
* Keys are expected to exist with aliases in the form of `$partnerId.$keyId`.<br>
* Assuming your partner-id is "abc" and you want to store a key with ID "1", you can generate a compatible P12 file as
* follows:<br>
* <br>
* <pre>keytool -importpass -storetype pkcs12 -alias abc.1 -keystore filename.p12</pre>
* <br>
* When prompted for the keystore password, enter your desired keystore password, and when prompted for the password
* to save, paste in the API key that was provided to you.
*/
public class KeystoreKeyProvider implements KeyProvider {
private final KeyStore.PasswordProtection keystorePassword;
private final KeyStore keyStore;
private final SecretKeyFactory keyFactory;
/**
* Create a key provider backed by a pre-loaded KeyStore.
*
* @param keyStore The KeyStore instance
* @param password The KeyStore password, required to access individual entries
*/
public KeystoreKeyProvider(KeyStore keyStore, String password) {
this.keystorePassword = new KeyStore.PasswordProtection(password.toCharArray());
this.keyStore = keyStore;
try {
this.keyFactory = SecretKeyFactory.getInstance("PBE");
} catch (NoSuchAlgorithmException ex) {
throw new IllegalStateException("No PBE (password based encryption) support?", ex);
}
}
/**
* Create a key provider backed by the given PKCS12 (.p12) file.
*
* @param filename The path to the p12 file on the filesystem
* @param password The keystore password, required to open the file and access individual entries
* @return A {@link KeystoreKeyProvider} instance. Does not return null.
* @throws IOException If there was an IO error loading the file.
*/
public static KeystoreKeyProvider fromPKCS12(String filename, String password) throws IOException {
KeyStore keyStore;
try {
keyStore = KeyStore.getInstance("PKCS12");
} catch (KeyStoreException ex) {
throw new IllegalStateException("No P12 support?", ex);
}
try {
keyStore.load(new FileInputStream(filename), password.toCharArray());
} catch (NoSuchAlgorithmException | CertificateException ex) {
throw new IllegalStateException("Error loading " + filename, ex);
}
return new KeystoreKeyProvider(keyStore, password);
}
@Override
public synchronized String get(String partnerId, String keyId) {
String alias = partnerId + "." + keyId;
KeyStore.SecretKeyEntry entry;
try {
entry = (KeyStore.SecretKeyEntry)this.keyStore.getEntry(alias, this.keystorePassword);
} catch (NoSuchAlgorithmException | UnrecoverableEntryException | KeyStoreException ex) {
throw new IllegalStateException("Failed to load " + alias + ": " + ex.getMessage(), ex);
}
if (entry == null) {
return null;
}
PBEKeySpec keySpec;
try {
keySpec = (PBEKeySpec)this.keyFactory.getKeySpec(entry.getSecretKey(), PBEKeySpec.class);
} catch (InvalidKeySpecException ex) {
throw new IllegalStateException(ex);
}
return new String(keySpec.getPassword());
}
}
|
package cit360acp;
import java.util.HashMap;
public class ApplicationController {
private HashMap<String,Handler> handlerMap = new HashMap();
public void handleRequest(String command){
Handler aCommandHandler = handlerMap.get(command);
if (aCommandHandler != null){
aCommandHandler.handleIt();
}
}
public void mapCommand(String aCommand, Handler acHandler){
handlerMap.put(aCommand,acHandler);
}
}
|
package com.abd.rest.restsecurity.controllers;
import com.abd.rest.restsecurity.model.Product;
import com.abd.rest.restsecurity.repositories.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Optional;
@RestController
public class ProductController {
@Autowired
ProductRepository productRepository;
@RequestMapping(method=RequestMethod.GET, value="/api/products")
public Iterable<Product> product() {
return productRepository.findAll();
}
@RequestMapping(method=RequestMethod.POST, value="/api/products")
public Long save(@RequestBody Product product) {
productRepository.save(product);
return product.getId();
}
@RequestMapping(method= RequestMethod.GET, value="/api/products/{id}")
public Optional<Product> show(@PathVariable Long id) {
return productRepository.findById(id);
}
@RequestMapping(method=RequestMethod.PUT, value="/api/products/{id}")
public Product update(@PathVariable Long id, @RequestBody Product product) {
Optional<Product> optionalProduct = productRepository.findById(id);
if(optionalProduct.isPresent()) {
Product p = optionalProduct.get();
if (product.getProdName() != null)
p.setProdName(product.getProdName());
if (product.getProdDesc() != null)
p.setProdDesc(product.getProdDesc());
if (product.getProdPrice() != null)
p.setProdPrice(product.getProdPrice());
if (product.getProdImage() != null)
p.setProdImage(product.getProdImage());
productRepository.save(p);
return p;
}
return null;
}
@RequestMapping(method=RequestMethod.DELETE, value="/api/products/{id}")
public String delete(@PathVariable Long id) {
Optional<Product> product = productRepository.findById(id);
productRepository.delete(product.get());
return "product deleted";
}
}
|
package com.saasxx.core.module.common.schema;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.SelectBeforeUpdate;
import com.saasxx.framework.dao.orm.annotation.Comment;
import com.saasxx.framework.dao.orm.schema.IdEntity;
@Entity
@Table(indexes = {})
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, include = "non-lazy")
@Comment("文件信息表")
@SelectBeforeUpdate(true)
@DynamicUpdate
@DynamicInsert
public class PFile extends IdEntity {
/**
*
*/
private static final long serialVersionUID = -6849233149940251401L;
@Column(length = 1024)
@Comment("文件路径")
private String path;
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
} |
package com.depi.entity;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
@Entity
@JsonIdentityInfo(
generator = ObjectIdGenerators.PropertyGenerator.class,
property = "id")
@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String studentNumber;
private String name;
private String lastName;
@OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
private Thesis thesis;
public Student() {}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getStudentNumber() {
return studentNumber;
}
public void setStudentNumber(String studentNumber) {
this.studentNumber = studentNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Thesis getThesis() {
return thesis;
}
public void setThesis(Thesis thesis) {
this.thesis = thesis;
}
}
|
package com.nisira.view.Adapter;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.nisira.gcalderon.policesecurity.R;
import java.util.List;
/**
* Created by gcalderon on 05/01/2017.
*/
public class Lista_Adapter extends RecyclerView.Adapter<Lista_Adapter.ListaViewHolder> {
private List<String> items;//Lo cambias por la coleccion que necesites Alex
public static class ListaViewHolder extends RecyclerView.ViewHolder {
// Campos respectivos de un item
public ImageView imagen;
public TextView nombre;
public ListaViewHolder(View v) {
super(v);
imagen = (ImageView) v.findViewById(R.id.imagen_personal);
nombre = (TextView) v.findViewById(R.id.nombre);
}
}
public Lista_Adapter(List<String> items) {
this.items = items;
}
@Override
public int getItemCount() {
return items.size();
}
@Override
public ListaViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
View v = LayoutInflater.from(viewGroup.getContext())
.inflate(R.layout.card_elementolista, viewGroup, false);
return new ListaViewHolder(v);
}
@Override
public void onBindViewHolder(ListaViewHolder viewHolder, int i) {
//AQUI VAN TODOS LOS ELEMENTOS DE LA LISTA.
//viewHolder.imagen.setImageResource());
viewHolder.nombre.setText(items.get(i));
}
} |
package Listener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.regex.Pattern;
import javax.swing.JButton;
import MobileKasse.Koch;
public class BestellungFertigListener implements ActionListener {
String nachricht;
Koch koch;
public BestellungFertigListener(String nachricht,Koch koch){
this.nachricht = nachricht;
this.koch = koch;
}
@Override
public void actionPerformed(ActionEvent arg0){
String[] segs = nachricht.split( Pattern.quote( "|" ) );
String bestellid = segs[1];
try{
koch.koch.Nodepublish("Kellner", nachricht);
//
for(int i=0;i<koch.buttons.size();i++){
String[] tmp =koch.buttons.get(i).getText().split( Pattern.quote( "|" ) );
System.out.println(bestellid);
System.out.println(tmp[0]);
if(tmp[0].equals(bestellid)){
koch.panel.remove(koch.buttons.get(i));
koch.buttons.remove(i);
}
}
koch.buttonsZeichnen();
}catch(Exception a){
System.out.println("Nachricht konnte nicht gepublished werden");
}
}
}
|
package gui.form.valid;
import gui.ComponentTools;
import gui.form.FormItem;
import gui.form.TextItem;
import gui.form.ValueChangeEvent;
import gui.form.ValueChangeListener;
import java.awt.Dimension;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
/**
* A SequenceValidator represents the logical concatenation of other
* validators. It starts out with an ordered collection of validators
* and applies each one, until one fails, or until all validate the
* data.
*
* This class allows one data source to have multiple "daisy-chained"
* validators. These validators are tested in order, so that more
* complex (slower) validation will only be done if easier (faster)
* validation succeeds.
*/
public class SequenceValidator extends ValidationAdapter
{
private static final long serialVersionUID = 5;
private List<Validator> sequence;
public SequenceValidator() { }
public SequenceValidator (final List<Validator> sequence)
{
this.sequence = sequence;
}
public void addValidator (final Validator v)
{
if (sequence == null)
sequence = new ArrayList<Validator>();
sequence.add (v);
}
public void removeValidator (final Validator v)
{
if (sequence != null)
sequence.remove (v);
}
@Override
public boolean isValid (final Object value)
{
if (sequence == null)
return true;
for (Validator v : sequence)
if (!v.isValid (value))
return false; // return at first failure
return true; // all passed
}
public static void main (final String[] args) // for testing
{
try
{
TextItem item = new TextItem ("Sequence Validator Test");
SequenceValidator v = new SequenceValidator();
v.addValidator (new NumericValidator());
v.addValidator (new RegexValidator (".*123.*"));
item.setValidator (v);
item.addValueChangeListener (
new ValueChangeListener()
{
public void valueChanged (final ValueChangeEvent e)
{
FormItem comp = (FormItem) e.getSource();
System.out.println (comp.getLabel() + ": " + comp.getValue());
}
});
item.getComponent().setPreferredSize (new Dimension (200, 50));
final JFrame frame = new JFrame (SequenceValidator.class.getName());
frame.getContentPane().add (item.getComponent());
// do the following on the GUI event-dispatching thread
SwingUtilities.invokeLater (new Runnable() {
public void run()
{
frame.pack();
ComponentTools.centerComponent (frame);
frame.setVisible (true);
}
});
}
catch (Exception e)
{
System.err.println (e + ": " + e.getMessage());
e.printStackTrace (System.err);
}
}
}
|
package com.mad.cityassignment;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import java.io.Serializable;
import static java.lang.Math.min;
public class GameData implements Serializable {
private MapData md;
private int money, gameTime;
public GameData(int height, int width, int money){
this.md = MapData.get(height, width);
this.money = money;
this.gameTime = 0;
}
public MapData getMapData() { return this.md; }
public int getMoney() { return this.money; }
public void setMoney(int money) {
this.money = money;
}
public int getGameTime() {return this.gameTime;}
public void setGameTime(int time) {this.gameTime = time;}
public int getPopulation(int familySize) {
int resCount = 0;
int population = familySize;
for(int i = 0; i < md.getHeight(); i++){
for (int j = 0; j < md.getWidth(); j++){
if (md.getElement(i,j).getStructure() != null){
if (md.getElement(i,j).getStructure().getLabel().contains("Residential")) {
resCount = resCount + 1;
}
}
}
}
population = population * resCount;
return population;
}
public int getEmploymentRate(int shopSize, int population){
int comCount = 0;
for(int i = 0; i < md.getHeight(); i++){
for (int j = 0; j < md.getWidth(); j++){
if (md.getElement(i,j).getStructure() != null){
if (md.getElement(i,j).getStructure().getLabel().contains("Commercial")) {
comCount = comCount + 1;
}
}
}
}
System.out.println(comCount);
//int employmentRate = min(1, (comCount * shopSize / population));
int employmentRate = (comCount * shopSize / population);
return employmentRate;
}
}
|
package com.lenovohit.hcp.odws.web.rest;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject;
import com.lenovohit.core.manager.GenericManager;
import com.lenovohit.core.web.MediaTypes;
import com.lenovohit.core.web.utils.Result;
import com.lenovohit.core.web.utils.ResultUtils;
import com.lenovohit.hcp.base.model.Department;
import com.lenovohit.hcp.base.model.HcpUser;
import com.lenovohit.hcp.base.web.rest.HcpBaseRestController;
import com.lenovohit.hcp.odws.model.Diagnose;
/**
* 诊断
*/
@RestController
@RequestMapping("/hcp/odws/diagnose")
public class DiagnoseController extends HcpBaseRestController {
@Autowired
private GenericManager<Diagnose, String> diagnoseManager;
/**
* 根据挂号id取对应的所有诊断
*
* @param regId
* @return
*/
@RequestMapping(value = "/list/{regId}", method = RequestMethod.GET, produces = MediaTypes.JSON_UTF_8)
public Result forDiagnosisPage(@PathVariable("regId") String regId) {
List<Object> values = new ArrayList<Object>();
StringBuilder jql = new StringBuilder("from Diagnose where regId = ? order by sortNo ");
values.add(regId);
List<Diagnose> list = (List<Diagnose>) diagnoseManager.find(jql.toString(), values.toArray());
return ResultUtils.renderPageResult(list);
}
/**
* 保存诊断信息
*
* @param data
* @return
*/
@RequestMapping(value = "/save", method = RequestMethod.POST, produces = MediaTypes.JSON_UTF_8)
public Result forCreate(@RequestBody String data) {
HcpUser user = this.getCurrentUser();
JSONObject json = JSONObject.parseObject(data);
Diagnose model = new Diagnose();
model.setRegId(json.getString("regId"));
model.setDiseaseType("1"); // 类型：门诊诊断
model.setDiseaseId(json.getString("diagnosisCode"));
model.setDiseaseName(json.getString("diagnosisName"));
model.setDiseaseTime(new Date());
Department dept = new Department();
dept.setId(user.getLoginDepartment().getId());
model.setDiseaseDept(dept);
HcpUser doctor = new HcpUser();
doctor.setId(user.getId());
model.setDiseaseDoc(doctor);
model.setIscurrent(json.getString("iscurrent"));
model.setStopFlag("1");
model.setSortNo(json.getInteger("sortNo"));
Diagnose saved = diagnoseManager.save(model);
return ResultUtils.renderSuccessResult(saved);
}
/**
* 设置主诊断
*
* @param regId
* @param id
* @return
*/
@RequestMapping(value = "/setMainDiagnose/{regId}/{id}", method = RequestMethod.GET, produces = MediaTypes.JSON_UTF_8)
public Result forSetMainDiagnose(@PathVariable("regId") String regId, @PathVariable("id") String id) {
//根据挂号id查询对应的所有诊断
List<Object> values = new ArrayList<Object>();
StringBuilder jql = new StringBuilder("from Diagnose where regId = ? order by sortNo ");
values.add(regId);
List<Diagnose> list = (List<Diagnose>) diagnoseManager.find(jql.toString(), values.toArray());
//变更主诊断标识及序号
int i = 2;
for(Diagnose diagnose : list) {
if (diagnose.getId().equals(id)) {
diagnose.setIscurrent("1");
diagnose.setSortNo(1);
} else {
diagnose.setIscurrent("0");
diagnose.setSortNo(i);
i += 1;
}
diagnoseManager.save(diagnose);
}
return ResultUtils.renderSuccessResult();
}
/**
* 删除诊断
*
* @param regId
* @param id
* @return
*/
@RequestMapping(value = "/delete/{regId}/{id}", method = RequestMethod.GET, produces = MediaTypes.JSON_UTF_8)
public Result forDelete(@PathVariable("regId") String regId, @PathVariable("id") String id) {
//根据挂号id查询对应的所有诊断
List<Object> values = new ArrayList<Object>();
StringBuilder jql = new StringBuilder("from Diagnose where regId = ? order by sortNo ");
values.add(regId);
List<Diagnose> list = (List<Diagnose>) diagnoseManager.find(jql.toString(), values.toArray());
//删除诊断，并变更其他诊断的主诊断标识及序号
int i = 1;
for(Diagnose diagnose : list) {
if (diagnose.getId().equals(id)) {
diagnoseManager.delete(diagnose);
} else {
if (i == 1) diagnose.setIscurrent("1");
else diagnose.setIscurrent("0");
diagnose.setSortNo(i);
i += 1;
diagnoseManager.save(diagnose);
}
}
return ResultUtils.renderSuccessResult();
}
/**
* 取当前登录医生常用的20条诊断
* @return
*/
@RequestMapping(value = "/list/top", method = RequestMethod.GET, produces = MediaTypes.JSON_UTF_8)
public Result forTopDiagnosis() {
//当前登录用户
HcpUser user = this.getCurrentUser();
List<Object> values = new ArrayList<Object>();
StringBuilder jql = new StringBuilder("select d.diseaseId, d.diseaseName, ");
jql.append("bd.phoneticCode, bd.wangCode, count(*) as sumCount ");
jql.append("from Diagnose d, Diagnosis bd where d.diseaseDoc.id = ? and d.diseaseId = bd.diagnosisCode ");
jql.append("group by d.diseaseId, d.diseaseName, bd.phoneticCode, bd.wangCode order by sumCount desc");
values.add(user.getId());
List<Object> list = (List<Object>) diagnoseManager.findPageList(0, 20, jql.toString(), values.toArray());
return ResultUtils.renderPageResult(list);
}
}
|
package IteratorPattern;
public class MenuByArray extends MenuComponent{
private static final int ITEMS_MAX = 7;
private MenuComponent[] list;
private String name;
private String description;
int offNumber = 0;
public MenuByArray(String name,String description) {
super();
this.list = new MenuComponent[ITEMS_MAX];
this.name = name;
this.description = description;
}
@Override
public String getName() {
// TODO Auto-generated method stub
return name;
}
@Override
public String getDescription() {
// TODO Auto-generated method stub
return description;
}
@Override
public void add(MenuComponent menuComponent) {
// TODO Auto-generated method stub
while ((offNumber<ITEMS_MAX)&&(list[offNumber]!=null)) {
offNumber++;
}
if (offNumber < ITEMS_MAX) {
list[offNumber] = menuComponent;
offNumber = 0;
}else {
System.out.println("No position to add menuItem!!");
offNumber = 0;
}
}
@Override
public void remove(MenuComponent menuComponent) {
// TODO Auto-generated method stub
for (int i = 0; i < ITEMS_MAX; i++) {
if (list[i] == menuComponent) {
list[i] = null;
}
}
}
@Override
public MenuComponent getChild(int index) {
// TODO Auto-generated method stub
if (index < ITEMS_MAX&&list[index]!=null) {
return list[index];
}else {
return null;
}
}
@Override
public void print() {
// TODO Auto-generated method stub
System.out.println(name+"---"+description+"---");
ArrayIterator arrayIterator = createIterator();
while (arrayIterator.hasNext()) {
MenuComponent object = arrayIterator.next();
object.print();
}
}
public ArrayIterator createIterator() {
return new ArrayIterator(list);
}
}
|
package edu.eam.ingesoft.ejemploback.services;
import edu.eam.ingesoft.ejemploback.model.Cliente;
import edu.eam.ingesoft.ejemploback.model.Cuenta;
import edu.eam.ingesoft.ejemploback.model.Transaccion;
import edu.eam.ingesoft.ejemploback.repositories.CuentaRepository;
import edu.eam.ingesoft.ejemploback.repositories.TransaccionRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class TransaccionService {
@Autowired
private TransaccionRepository transaccionRepository;
@Autowired
private CuentaRepository cuentaRepository;
public void crearTransaccion(Transaccion transaccion){
Cuenta cuenta = cuentaRepository.findById(transaccion.getNumerocuenta()).orElse(null);
if (cuenta==null){
throw new RuntimeException("No existe la cuenta");
}
double dineroC = cuenta.getAmount();
double dineroT = transaccion.getMonto();
double dineroTotal= dineroC + dineroT;
cuenta.setAmount(dineroTotal);
transaccionRepository.save(transaccion);
}
public void consignarDinero(Transaccion transaccion) {
Cuenta cuenta = cuentaRepository.findById(transaccion.getNumerocuenta()).orElse(null);
if (cuenta == null) {
throw new RuntimeException("No existe la cuenta");
}
double dineroC = cuenta.getAmount();
double dineroT = transaccion.getMonto();
double dineroTotal = dineroC + dineroT;
cuenta.setAmount(dineroTotal);
transaccionRepository.save(transaccion);
}
public void retirarDinero(Transaccion transaccion) {
Cuenta cuenta = cuentaRepository.findById(transaccion.getNumerocuenta()).orElse(null);
if (cuenta == null) {
throw new RuntimeException("No existe la cuenta");
}
double dineroC = cuenta.getAmount();
double dineroT = transaccion.getMonto();
double dineroTotal = dineroC - dineroT;
cuenta.setAmount(dineroTotal);
transaccionRepository.save(transaccion);
}
public void transferirDinero(Transaccion transaccion){
//Validar Existencia de la cuenta remitente
Cuenta cuentaRemite = cuentaRepository.findById(transaccion.getNumerocuenta()).orElse(null);
if (cuentaRemite==null){
throw new RuntimeException("No existe la cuenta remitente ");
}
//Validar Existencia de la cuenta destino
Cuenta cuentaDestino = cuentaRepository.findById(transaccion.getNumerocuenta2()).orElse(null);
if (cuentaDestino==null){
throw new RuntimeException("No existe la cuenta destino ");
}
//Validar que no exista transaccion
Transaccion transaccion1 = transaccionRepository.findById(transaccion.getNumero()).orElse(null);
if (transaccion1!=null){
throw new RuntimeException("Ya existe la transaccion");
}
// Se obtiene el dinero de las cuentas y el de transaccion
double dineroCR = cuentaRemite.getAmount();
double dineroCD = cuentaDestino.getAmount();
double dineroT = transaccion.getMonto();
//Se aplica la resta y suma de las cuentas
double dineroResta= dineroCR - dineroT;
double dineroSuma= dineroCD + dineroT;
cuentaRemite.setAmount(dineroResta);
cuentaDestino.setAmount(dineroSuma);
//Guardar la transaccion
transaccionRepository.save(transaccion);
}
//listar transacciones de cliente
public List<Transaccion> listarTransaccionesCuenta(String id) {
return transaccionRepository.buscarTransaccionesCuenta(id);
}
} |
/*
* Test 32
*
* Testiamo ora l'operatore di negazione.
*/
class HelloWorld {
static public void main(String[] argv)
{
short a=(short)10;
int i=2;
long k=3, m;
float t=(float)3.2;
double x, y=10.3;
m=-i;
System.out.println(m); // stampo -2.
m=-a;
System.out.println(m); // stampo -10.
x=-t;
System.out.println(x); // stampo -3.2.
x=-y;
System.out.println(x); // stampo -10.3.
}
}
|
package com.yuneec.flightmode15;
import android.content.Context;
import android.os.Environment;
import android.os.Handler;
import android.os.storage.StorageManager;
import com.yuneec.IPCameraManager.DES;
import com.yuneec.uartcontroller.GPSUpLinkData;
import com.yuneec.uartcontroller.UARTInfoMessage.Telemetry;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class FlightLog {
private static FlightLog instance = null;
private static int maxNum = 10000;
private static int reserveNum = 100;
private String apppath = "sdcard";
private Runnable closeFlightModeRunnable = new Runnable() {
public void run() {
if (!FlightLog.this.isCreatedNode) {
FlightLog.this.flightNoteClose();
}
}
};
private Context context;
private boolean isCreatedNode = false;
private Handler mHandler = new Handler();
private FileOutputStream mRemoteFos = null;
private FileOutputStream mRemoteGpsFos = null;
private FileOutputStream mTelemetryFos = null;
private String remFilePath;
private String remGPSFilePath;
private String telFilePath;
private FlightLog() {
}
public static FlightLog getInstance() {
if (instance == null) {
instance = new FlightLog();
}
return instance;
}
public synchronized void createFlightNote(Context context) {
this.context = context;
this.isCreatedNode = true;
if (isSdCardExist()) {
this.apppath = sdCardPath()[0];
if (this.mRemoteGpsFos == null && this.mRemoteFos == null && this.mTelemetryFos == null) {
int logFileIndex = 1;
File blackBox = new File(this.apppath + "/FlightLog");
if (!blackBox.exists()) {
blackBox.mkdir();
}
File file = new File(this.apppath + "/FlightLog/Telemetry");
if (file.exists()) {
delOtherFile(this.apppath, file);
String[] names = file.list();
for (int i = 0; i < names.length; i++) {
if (names[i].contains("Telemetry")) {
int nameIndex = Integer.parseInt(names[i].substring(10, 15));
if (nameIndex > logFileIndex) {
logFileIndex = nameIndex;
}
}
}
if (logFileIndex == maxNum) {
logFileIndex = 1;
} else {
logFileIndex++;
}
} else {
file.mkdir();
}
delLogFile(logFileIndex, reserveNum, maxNum);
this.telFilePath = this.apppath + "/FlightLog/Telemetry/" + ("Telemetry_" + String.format("%05d", new Object[]{Integer.valueOf(logFileIndex)}) + ".csv");
String title = Telemetry.getParamsName();
try {
this.mTelemetryFos = new FileOutputStream(this.telFilePath);
this.mTelemetryFos.write(title.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
File remoteFile = new File(this.apppath + "/FlightLog/Remote");
if (!remoteFile.exists()) {
remoteFile.mkdir();
}
this.remFilePath = this.apppath + "/FlightLog/Remote/" + ("Remote_" + String.format("%05d", new Object[]{Integer.valueOf(logFileIndex)}) + ".csv");
String remTitle = ",CH0,CH1,CH2,CH3,CH4,CH5,CH6,CH7,CH8,CH9,CH10,CH11,CH12,CH13,CH14,CH15,CH16,CH17,CH18,CH19,CH20,CH21,CH22,CH23\n";
try {
this.mRemoteFos = new FileOutputStream(this.remFilePath);
this.mRemoteFos.write(remTitle.getBytes());
} catch (Exception e2) {
e2.printStackTrace();
}
File remoteGPSFile = new File(this.apppath + "/FlightLog/RemoteGPS");
if (!remoteGPSFile.exists()) {
remoteGPSFile.mkdir();
}
this.remGPSFilePath = this.apppath + "/FlightLog/RemoteGPS/" + ("RemoteGPS_" + String.format("%05d", new Object[]{Integer.valueOf(logFileIndex)}) + ".csv");
String remGPSTitle = GPSUpLinkData.getParamsName();
try {
this.mRemoteGpsFos = new FileOutputStream(this.remGPSFilePath);
this.mRemoteGpsFos.write(remGPSTitle.getBytes());
} catch (Exception e22) {
e22.printStackTrace();
}
}
}
}
public boolean isSdCardExist() {
return Environment.getExternalStorageState().equals("mounted");
}
private String[] sdCardPath() {
String[] paths = null;
StorageManager sm = (StorageManager) this.context.getSystemService("storage");
try {
paths = (String[]) sm.getClass().getMethod("getVolumePaths", null).invoke(sm, null);
int length = paths.length;
return paths;
} catch (Exception e) {
e.printStackTrace();
return paths;
}
}
public void saveTelemetryFos(byte[] fosData) {
try {
if (this.mTelemetryFos != null) {
this.mTelemetryFos.write(fosData);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void saveRemoteFos(byte[] fosData) {
try {
if (this.mRemoteFos != null) {
this.mRemoteFos.write(fosData);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void saveRemoteGpsFos(byte[] fosData) {
try {
if (this.mRemoteGpsFos != null) {
this.mRemoteGpsFos.write(fosData);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private void delLogFile(int logFileIndex, int reserveNum, int maxNum) {
int delLogFileIndex = logFileIndex - reserveNum;
if (logFileIndex < reserveNum) {
delLogFileIndex = (logFileIndex - reserveNum) + maxNum;
}
String delTelFileName = this.apppath + File.separator + "FlightLog" + File.separator + "Telemetry" + File.separator + "Telemetry_" + String.format("%05d", new Object[]{Integer.valueOf(delLogFileIndex)}) + ".csv";
String delRemFileName = this.apppath + File.separator + "FlightLog" + File.separator + "Remote" + File.separator + "Remote_" + String.format("%05d", new Object[]{Integer.valueOf(delLogFileIndex)}) + ".csv";
String delRemGPSFileName = this.apppath + File.separator + "FlightLog" + File.separator + "RemoteGPS" + File.separator + "RemoteGPS_" + String.format("%05d", new Object[]{Integer.valueOf(delLogFileIndex)}) + ".csv";
File fileDelTelFileName = new File(delTelFileName);
if (fileDelTelFileName.exists()) {
fileDelTelFileName.delete();
}
File fileDelRemFileName = new File(delRemFileName);
if (fileDelRemFileName.exists()) {
fileDelRemFileName.delete();
}
File fileDelRemGPSFileName = new File(delRemGPSFileName);
if (fileDelRemGPSFileName.exists()) {
fileDelRemGPSFileName.delete();
}
}
private void delOtherFile(String apppath, File telemtryFile) {
String[] names = telemtryFile.list();
for (String fileName : names) {
String fileLastName = fileName.substring(10, 15);
if (!fileName.contains("Telemetry_") || !fileLastName.matches("[0-9]+")) {
File file = new File(new StringBuilder(String.valueOf(apppath)).append("/FlightLog/Telemetry/").append(fileName).toString());
if (file.exists()) {
file.delete();
}
}
}
}
public synchronized void closedFlightNote(boolean forceClose) {
if (forceClose) {
flightNoteClose();
this.isCreatedNode = false;
this.mHandler.removeCallbacksAndMessages(null);
} else if (this.isCreatedNode) {
this.isCreatedNode = false;
this.mHandler.removeCallbacks(this.closeFlightModeRunnable);
this.mHandler.postDelayed(this.closeFlightModeRunnable, 30000);
}
}
private void flightNoteClose() {
if (this.mTelemetryFos != null) {
try {
this.mTelemetryFos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (this.mRemoteFos != null) {
try {
this.mRemoteFos.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
if (this.mRemoteGpsFos != null) {
try {
this.mRemoteGpsFos.close();
} catch (Exception e22) {
e22.printStackTrace();
}
}
if (!(this.mRemoteGpsFos == null && this.mRemoteFos == null && this.mTelemetryFos == null)) {
encryptLog();
}
this.mRemoteGpsFos = null;
this.mRemoteFos = null;
this.mTelemetryFos = null;
}
private void encryptLog() {
DES.logEncrypt(this.telFilePath);
this.telFilePath = null;
DES.logEncrypt(this.remFilePath);
this.remFilePath = null;
DES.logEncrypt(this.remGPSFilePath);
this.remGPSFilePath = null;
}
}
|
public class CircleController extends VehicleController{
public CircleController(Simulator s, GroundVehicle v) {
super(s, v);
}
@Override
void constructionTasks(){
}
@Override
public Control getControl(Timestamp time){
double[] thisPose = this.getPosition();
double offset=Math.sqrt((thisPose[0]-50)*(thisPose[0]-50)+(thisPose[1]-50)*(thisPose[1]-50))-25;
double thetaErr = util.wrapAngle(Math.atan2(thisPose[1]-50, thisPose[0]-50)+Math.PI/2-thisPose[2]);
return new Control(10, 0.4+offset/25+(1-offset/25)*thetaErr);
}
}
|
package com.example.vplayer.ui.fragment;
import android.app.ProgressDialog;
import android.content.ContentUris;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.FileProvider;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.DefaultItemAnimator;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import com.example.vplayer.R;
import com.example.vplayer.fragment.adapter.MusicAdapter;
import com.example.vplayer.fragment.adapter.MusicSAdapter;
import com.example.vplayer.fragment.adapter.VideoSAdapter;
import com.example.vplayer.fragment.utils.VideoPlayerUtils;
import com.example.vplayer.model.AudioModel;
import com.example.vplayer.service.MusicService;
import com.example.vplayer.service.VideoDataService;
import com.example.vplayer.ui.activity.SelectItemActivity;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import static com.example.vplayer.service.MusicDataService.audioList;
public class MusicSFragment extends Fragment {
View view;
RecyclerView recycler_view;
ImageView emptyString;
MusicSAdapter adapter;
ProgressDialog loadingDialog;
SwipeRefreshLayout refreshLayout;
TextView select_all;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
view = inflater.inflate( R.layout.music_s_fragment, container, false);
recycler_view = view.findViewById(R.id.recycler_view);
emptyString = view.findViewById(R.id.emptyString);
// progress_bar = view.findViewById(R.id.progress_bar);
refreshLayout = view.findViewById(R.id.refreshLayout);
select_all = view.findViewById(R.id.select_all);
return view;
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
refreshLayout.setEnabled(false);
initView();
}
public void initView() {
//progress_bar.setVisibility(View.VISIBLE);
new Thread(this::getAllAudioList).start();
/*loadingDialog = new ProgressDialog(getActivity());
loadingDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
loadingDialog.setCancelable(false);
loadingDialog.setMessage("Fetching list...");
loadingDialog.setCanceledOnTouchOutside(false);*/
}
private void getAllAudioList() {
getActivity().runOnUiThread(new Runnable() {
@Override
public void run() {
setAdapter();
}
});
}
public void setAdapter() {
//progress_bar.setVisibility(View.GONE);
recycler_view.setVisibility(View.VISIBLE);
emptyString.setVisibility(View.GONE);
LinearLayoutManager layoutManager = new LinearLayoutManager(getActivity());
recycler_view.setLayoutManager(layoutManager);
adapter = new MusicSAdapter(getActivity(), audioList, true);
recycler_view.setAdapter(adapter);
adapter.setOnItemClickListener(new MusicSAdapter.ClickListener() {
@Override
public void onItemClick(int position, View v) {
AudioModel current = audioList.get(position);
if(current.isSelected()) {
audioList.get(position).setSelected(false);
SelectItemActivity.SelectCount--;
}
else {
audioList.get(position).setSelected(true);
SelectItemActivity.SelectCount++;
}
SelectItemActivity.text_title.setText(SelectItemActivity.SelectCount + " selected");
adapter.notifyItemChanged(position);
}
});
select_all.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
AudioModel current = new AudioModel();
if(select_all.getText().equals("UNSELECT ALL")){
for(int i = 0; i< audioList.size(); i++) {
current = audioList.get(i);
current.setSelected(false);
SelectItemActivity.SelectCount--;
}
} else{
for(int i = 0; i< audioList.size(); i++) {
current = audioList.get(i);
current.setSelected(true);
SelectItemActivity.SelectCount++;
}
}
if(current.isSelected()){
select_all.setText("UNSELECT ALL");
} else {
select_all.setText("SELECT ALL");
}
SelectItemActivity.text_title.setText(SelectItemActivity.SelectCount + " selected");
adapter.notifyDataSetChanged();
}});
}
} |
import java.util.*;
public class GeneticAlgorithm {
// Static algorithm parameters
private int NUM_QUEENS; // Width and height of board equal to number of Queens in problem
private int MAX_ITERATIONS; // Maximum number of cycles before manual termination of program
private int POPULATION_SIZE; // Default size of the initial population
private double BREEDING_REQUIREMENT; // Percentage threshold of inbreeding of two selections
private int OFFSPRING; // Maximum number of offspring created during crossover
// Instance variables
private ArrayList<Chromosome> population = new ArrayList<Chromosome>();
private List<Chromosome> solutionList;
public Random rand = new Random();
public int iteration;
public int populationSize;
// Defaul Constructor
public GeneticAlgorithm(int num) {
NUM_QUEENS = num;
POPULATION_SIZE = 50;
MAX_ITERATIONS = 1000;
BREEDING_REQUIREMENT = 0.75;
OFFSPRING = 20;
population = new ArrayList<Chromosome>();
solutionList = new ArrayList<Chromosome>();
rand = new Random();
iteration = 0;
populationSize = 0;
}
public boolean Run()
{
boolean complete = false;
Chromosome chromo;
ArrayList<Chromosome> result;
for(int a = 0; a < POPULATION_SIZE; a++) {
InitializeBoard();
}
while(!complete)
{
populationSize = population.size();
for(int i = 0; i < populationSize; i++)
{
chromo = population.get(i);
if(chromo.GetCrashes() == 0)
{
if(CheckSolutions(chromo) == false)
solutionList.add(chromo);
}
}
if(iteration == MAX_ITERATIONS)
{
complete = true;
}
EvaluateFitness();
result = KWayTournamentSelection(3);
population = result;
populationSize = population.size();
result = Crossover();
population = result;
populationSize = population.size();
Mutation();
for(Chromosome c : population)
{
c.CountCrashes();
}
Repopulate();
iteration++;
System.out.println("Iteration: " + iteration);
System.out.println("Solutions Found: " + solutionList.size());
}
return complete;
}
private boolean CheckSolutions(Chromosome check)
{
Chromosome temp;
for (int i = 0; i < solutionList.size(); i++)
{
temp = solutionList.get(i);
if(temp.queenLayout.equals(check.queenLayout))
return true;
}
return false;
}
private void InitializeBoard() {
Chromosome newChromosome = new Chromosome(NUM_QUEENS);
ArrayList<Integer> randList = new ArrayList<Integer> ();
int position, value;
for(int i = 0; i <= 7; i++)
{
randList.add(i);
}
for (int i = 0; i < NUM_QUEENS; i++) {
if(randList.size() > 1) {
position = rand.nextInt(randList.size() - 1);
}
else
{
position = 0;
}
value = randList.get(position);
randList.remove(position);
newChromosome.queenLayout.add(value);
}
newChromosome.CountCrashes();
population.add(newChromosome);
}
private void EvaluateFitness()
{
Chromosome tempChromo;
double highScore;
double lowScore;
// Compute high and low score as a weighted percentage
lowScore = GetLowScore(population);
highScore = lowScore - GetHighScore(population);
for(int i = 0; i < populationSize; i++)
{
tempChromo = population.get(i);
tempChromo.SetFitnessScore((lowScore - tempChromo.GetCrashes()) * 100.0 / highScore);
}
}
private double GetHighScore(ArrayList<Chromosome> inputList)
{
double bestScore = 28;
Chromosome temp;
for(int i = 0; i < populationSize; i++)
{
temp = population.get(i);
if(temp.GetCrashes() < bestScore) {
bestScore = temp.GetCrashes();
}
}
return bestScore;
}
private double GetLowScore(ArrayList<Chromosome> inputList)
{
double worstScore = 0;
Chromosome temp;
for(int i = 0; i < populationSize; i++)
{
temp = population.get(i);
if(temp.GetCrashes() > worstScore)
{
worstScore = temp.GetCrashes();
}
}
return worstScore;
}
public ArrayList<Chromosome> KWayTournamentSelection(int k)
{
ArrayList<Chromosome> newPopulation = new ArrayList<Chromosome>();
ArrayList<Chromosome> tempArray = new ArrayList<Chromosome>();
Chromosome tempChromosome;
int index = 0;
int selectedIndex = 0;
while(population.size() > 1)
{
tempArray.clear();
double max = 0;
for (int i = 0; i < k; i++)
{
if(population.size() > 0) {
if (population.size() > 1) {
index = rand.nextInt(population.size() - 1);
} else {
index = 0;
}
tempChromosome = population.get(index);
tempArray.add(tempChromosome);
}
}
for(int j = 0; j < tempArray.size(); j++)
{
tempChromosome = tempArray.get(j);
if(tempChromosome.GetFitness() > max) {
max = tempChromosome.GetFitness();
selectedIndex = j;
}
}
newPopulation.add(tempArray.get(selectedIndex));
population.remove(index);
}
return newPopulation;
}
public ArrayList<Chromosome> Crossover()
{
int mateProbability = 0;
int indexParentA, indexParentB;
int crossoverPoint;
Chromosome chromosomeA, chromosomeB;
int crossA, crossB;
ArrayList<Chromosome> newPopulation = new ArrayList<Chromosome>();
for (int i = 0; i < population.size(); i++)
{
indexParentA = rand.nextInt(population.size());
mateProbability = rand.nextInt(100);
if(mateProbability <= BREEDING_REQUIREMENT * 100)
{
do {
indexParentB = rand.nextInt(population.size());
} while (indexParentB == indexParentA);
chromosomeA = population.get(indexParentA);
chromosomeB = population.get(indexParentB);
crossoverPoint = rand.nextInt(7);
for (int j = 0; j < crossoverPoint; j++)
{
crossA = chromosomeA.queenLayout.get(j);
crossB = chromosomeB.queenLayout.get(j);
chromosomeA.SetQueenPosition(j, crossB);
chromosomeB.SetQueenPosition(j, crossA);
}
if(indexParentA < population.size())
population.remove(indexParentA);
if(indexParentB < population.size())
population.remove(indexParentB);
newPopulation.add(chromosomeA);
newPopulation.add(chromosomeB);
}
}
return newPopulation;
}
public void Mutation()
{
int mutationIndex;
int value;
Chromosome temp;
for (int i = 0; i < population.size(); i++)
{
temp = population.get(i);
mutationIndex = rand.nextInt(7);
value = temp.queenLayout.get(mutationIndex);
if(value != 7)
{
temp.queenLayout.set(mutationIndex, value + 1);
population.set(i, temp);
}
}
}
public void Repopulate()
{
for(int i = population.size(); i < POPULATION_SIZE; i++)
{
InitializeBoard();
}
}
public int GetRandom(int min, int max) {
return (int)Math.round((max - min) * rand.nextDouble() + min);
}
} |
package com.esum.comp.soappull;
import java.io.File;
import java.io.IOException;
import com.esum.framework.common.util.FileUtil;
import com.esum.framework.common.util.SysUtil;
import com.esum.framework.core.component.ComponentException;
import com.esum.framework.core.component.config.ComponentConfig;
import com.esum.framework.core.config.Configurator;
import com.esum.framework.core.exception.SystemException;
public class SoapPullConfig extends ComponentConfig {
public static String SOAPPULL_INFO_TABLE_ID = "soappull_info_id";
public static String MODULE_NAME;
public static boolean USE_SOAPPULL_SERVER = false;
public static int DEFAULT_GATHERING_COUNT = 50;
public static int DEFAULT_PERIOD = 7;
public static String INBOUND_PATH;
public static boolean USE_BACKUP;
public static String BACKUP_DIR;
public static boolean USE_ACK_SEND = false;
public static String ACK_CLASS;
public static int HTTP_CONNECTION_TIMEOUT = 60000;
public static int HTTP_READ_TIMEOUT = 60000;
// search documnet names
public static String DEFAULT_SEARCH_DOC_NAMES;
public static String LOCK_TABLE_NAME;
public static int FORCED_UNLOCK_INTERVAL_SEC;
protected SoapPullConfig(String componentId) {
super(componentId);
}
public void init() throws SystemException {
super.setInterfaceInfoTableId(SoapPullConfig.SOAPPULL_INFO_TABLE_ID);
try {
Configurator.init(getConfigId(), getInstallPath() + "/conf/soappull/config.properties");
} catch (IOException e) {
throw new ComponentException("init()", e.getMessage(), e);
}
MODULE_NAME = this.getComponentId();
String inboundPath = Configurator.getInstance(getConfigId()).getString("inbound.path");
try {
USE_SOAPPULL_SERVER = Configurator.getInstance(getConfigId()).getBoolean("use.soappull.server", false);
INBOUND_PATH = FileUtil.getAbsolutePath(inboundPath, true);
USE_BACKUP = Configurator.getInstance(getConfigId()).getBoolean("inbound.dime.backup.use", false);
BACKUP_DIR = SysUtil.replacePropertyToValue(Configurator.getInstance(getConfigId()).getString("inbound.dime.backup.dir",
SoapPullConfig.INBOUND_PATH + File.separator + "backup"));
DEFAULT_GATHERING_COUNT = Configurator.getInstance(getConfigId()).getInt("default.gathering.count", 100);
USE_ACK_SEND = Configurator.getInstance(getConfigId()).getBoolean("use.acknowledge.send", false);
ACK_CLASS = Configurator.getInstance(getConfigId()).getString("acknowledge.create.class", "");
HTTP_CONNECTION_TIMEOUT = Configurator.getInstance(getConfigId()).getInt("http.connection.timeout", 60000);
HTTP_READ_TIMEOUT = Configurator.getInstance(getConfigId()).getInt("http.read.timeout", 60000);
DEFAULT_SEARCH_DOC_NAMES = Configurator.getInstance(getConfigId()).getString(
"default.search.doc.names", "ORDERS,RECADV,RETANN,INVOIC,ORDCHG,RETANN");
} catch (IOException e) {
throw new SoapPullException("init()", e.getMessage(), e);
}
LOCK_TABLE_NAME = Configurator.getInstance(getConfigId()).getString("lock.table.name", null);
FORCED_UNLOCK_INTERVAL_SEC = Configurator.getInstance(getConfigId()).getInt("forced.unlock.interval", 600);
}
protected void destroyOtherConfigs() throws SystemException {
}
} |
package com.eighteengray.procamera.activity;
import android.app.Activity;
import android.os.Bundle;
import com.eighteengray.procamera.contract.ISettingContract;
/**
* 功能：
* 1.图像、视频录制质量、格式调节
* 2.九宫格、平衡器、防手抖、静音、
* 3.实时直方图
* 4.签名，包括日期、位置、版权、字号、颜色
* 设置信息写入SP
*/
public class SettingActivity extends Activity implements ISettingContract.IView
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
}
}
|
/*
* 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 library.system.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import library.system.database.Database;
import library.system.model.Book;
/**
*
* @author Sithu
*/
public class BookDAO {
public void saveBook(Book book) throws SQLException {
Connection conn = Database.getInstance().getConnection();
if(book.getId()==0){
String sql = "insert into lbdb.books (title,author,publisher) values (?,?,?)";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setString(1, book.getTitle());
stmt.setString(2, book.getAuthor());
stmt.setString(3, book.getPublisher());
stmt.execute();
}else{
String sql = "insert into lbdb.books (id,title,author,publisher) values (?,?,?,?)";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setInt(1,book.getId());
stmt.setString(2, book.getTitle());
stmt.setString(3, book.getAuthor());
stmt.setString(4, book.getPublisher());
stmt.execute();
}
}
public ObservableList<Book> getBooks() throws SQLException{
Connection conn = Database.getInstance().getConnection();
String sql = "select * from lbdb.books";
Statement stmt = conn.createStatement();
ResultSet result = stmt.executeQuery(sql);
ObservableList<Book> bookList = FXCollections.observableArrayList();
while(result.next()){
int id = result.getInt("id");
String title = result.getString("title");
String author = result.getString("author");
String publisher = result.getString("publisher");
Book book = new Book(id,title,author,publisher);
bookList.add(book);
}
return bookList;
}
public void deleteBook(int id) throws SQLException{
Connection conn = Database.getInstance().getConnection();
String sql = "delete from lbdb.books where id=?";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setInt(1, id);
stmt.execute();
}
public void updateBook(Book book) throws SQLException {
Connection conn = Database.getInstance().getConnection();
String sql = "update lbdb.books set title=?,author=?,publisher=? where id=?";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setString(1, book.getTitle());
stmt.setString(2, book.getAuthor());
stmt.setString(3, book.getPublisher());
stmt.setInt(4,book.getId());
stmt.execute();
}
public Book getBook(int id) throws SQLException {
Connection conn = Database.getInstance().getConnection();
String sql = "select * from lbdb.books where id=?";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setInt(1, id);
ResultSet result = stmt.executeQuery();
Book book = null;
if(result.next()){
String title = result.getString("title");
String author = result.getString("author");
String publisher = result.getString("publisher");
boolean available = result.getBoolean("available");
book = new Book(id,title,author,publisher,available);
}
return book;
}
public void updateAvailable(int id,boolean available) throws SQLException{
Connection conn = Database.getInstance().getConnection();
String sql = "update lbdb.books set available=? where id=?";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setBoolean(1, available);
stmt.setInt(2, id);
stmt.execute();
}
}
|
/*
* 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 hoangduc.dtos;
import java.io.Serializable;
/**
*
* @author ADMIN
*/
public class PetDTO implements Serializable{
private String petname,type;
private int petid,userid;
private boolean status;
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public PetDTO() {
}
public PetDTO(String petname, String type) {
this.petname = petname;
this.type = type;
}
public PetDTO(String petname, String type, int petid, int userid) {
this.petname = petname;
this.type = type;
this.petid = petid;
this.userid = userid;
}
public String getPetname() {
return petname;
}
public void setPetname(String petname) {
this.petname = petname;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getPetid() {
return petid;
}
public void setPetid(int petid) {
this.petid = petid;
}
public int getUserid() {
return userid;
}
public void setUserid(int userid) {
this.userid = userid;
}
}
|
package ru.duester.streams.v8.sources;
import java.io.InputStream;
public class ByteInputStreamStreamSource implements IStreamSource<Byte> {
private InputStream inputStream;
public ByteInputStreamStreamSource(InputStream inputStream) {
this.inputStream = inputStream;
}
@Override
public Byte next() {
try {
return (byte) inputStream.read();
} catch (Exception e) {
return null;
}
}
}
|
package ua.com.rd.pizzaservice.repository.customer.inmem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import ua.com.rd.pizzaservice.domain.customer.Customer;
import ua.com.rd.pizzaservice.repository.customer.CustomerRepository;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@Repository
public class InMemCustomerRepository implements CustomerRepository {
@Autowired
private List<Customer> customers;
public InMemCustomerRepository() {
customers = new ArrayList<>();
}
public InMemCustomerRepository(List<Customer> customers) {
this.customers = customers;
}
public List<Customer> getCustomers() {
return customers;
}
@Override
public Customer saveCustomer(Customer customer) {
customers.add(customer);
return customer;
}
@Override
public Customer getCustomerById(Long id) {
for (Customer customer : customers) {
if (customer.getId().equals(id)) {
return customer;
}
}
return null;
}
@Override
public void updateCustomer(Customer customer) {
Customer customer1 = getCustomerById(customer.getId());
customer1.setName(customer.getName());
customer1.setAddresses(customer.getAddresses());
}
@Override
public Customer deleteCustomer(Customer customer) {
if (customers.remove(customer)) {
return customer;
}
return null;
}
@Override
public Set<Customer> findAll() {
return new HashSet<>(customers);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.