text stringlengths 10 2.72M |
|---|
package com.duofei.db.mongodb.repository;
import com.duofei.db.mongodb.entity.Admin;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
/**
* admin
* @author duofei
* @date 2019/9/28
*/
@Repository
public interface AdminRepository extends MongoRepository<Admin,String> {
}
|
public class ShutdownProgramm {
}
|
package com.anibal.educational.rest_service.comps.service;
import com.anibal.educational.rest_service.comps.util.RestServiceException;
@SuppressWarnings("serial")
public class TicketDistributionException extends RestServiceException {
public TicketDistributionException() {
}
public TicketDistributionException(String message) {
super(message);
}
public TicketDistributionException(Throwable cause) {
super(cause);
}
public TicketDistributionException(String message, Throwable cause) {
super(message, cause);
}
}
|
package com.dais.mapper;
import com.dais.model.Fmessage;
import com.dais.model.FmessageExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface FmessageMapper {
int countByExample(FmessageExample example);
int deleteByExample(FmessageExample example);
int deleteByPrimaryKey(Integer fid);
int insert(Fmessage record);
int insertSelective(Fmessage record);
List<Fmessage> selectByExample(FmessageExample example);
Fmessage selectByPrimaryKey(Integer fid);
int updateByExampleSelective(@Param("record") Fmessage record, @Param("example") FmessageExample example);
int updateByExample(@Param("record") Fmessage record, @Param("example") FmessageExample example);
int updateByPrimaryKeySelective(Fmessage record);
int updateByPrimaryKey(Fmessage record);
} |
package com.ha.cn.service.impl;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.ha.cn.dao.CallCenterManagementMapper;
import com.ha.cn.dao.ShAreaMapper;
import com.ha.cn.model.CallCenterManagement;
import com.ha.cn.model.ShArea;
import com.ha.cn.service.ICallCenterManagementService;
import com.ha.cn.service.IShAreaService;
import org.springframework.stereotype.Service;
/**
*
* CallCenterManagement 表数据服务层接口实现类
*
*/
@Service
public class ShAreaServiceImpl extends ServiceImpl<ShAreaMapper, ShArea> implements IShAreaService {
}
|
package controllers;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Writer;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@WebServlet(name = "time", urlPatterns = {"/time"})
public class TimeServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
LocalDateTime ldt = LocalDateTime.now();
String pattern = "dd.MM.yyyy HH:mm:ss";
DateTimeFormatter format = DateTimeFormatter.ofPattern(pattern);
String time = ldt.format(format);
StringBuilder sb = new StringBuilder();
String lastTime = "-";
for (Cookie cookie : request.getCookies()) {
if (cookie.getName().equals("lastTime")){
lastTime = URLDecoder.decode(cookie.getValue(), "UTF-8");
}
}
sb.append("<html>");
sb.append("<head>");
sb.append("</head>");
sb.append("<body>");
sb.append("<h2>");
sb.append("now time: ").append(time);
sb.append("<br/>");
sb.append("last time: ").append(lastTime);
sb.append("</h2>");
sb.append("</body>");
sb.append("</html>");
Cookie cookie = new Cookie("lastTime", URLEncoder.encode(time, "UTF-8"));
cookie.setMaxAge(3600);
cookie.setPath("/");
response.addCookie(cookie);
response.setContentType("text/html");
Writer writer = response.getWriter();
writer.write(sb.toString());
writer.close();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
}
|
package jp.smartcompany.job.modules.core.pojo.entity;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import jp.smartcompany.job.modules.base.pojo.entity.BaseBean;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;
/**
* @author Xiao Wenpeng
*/
@TableName("t_login_audit")
@ToString
@Getter
@Setter
@Accessors(chain = true)
@EqualsAndHashCode(of = "auditId",callSuper = true)
public class LoginAuditDO extends BaseBean {
@TableId
private Long auditId;
private String username;
private String operation;
private Boolean status;
private String ip;
private String userAgent;
}
|
package com.example.myreadproject8.ui.activity;
import androidx.annotation.Nullable;
import androidx.appcompat.app.ActionBar;
import androidx.appcompat.widget.Toolbar;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.method.ScrollingMovementMethod;
import android.view.View;
import com.example.myreadproject8.R;
import com.example.myreadproject8.common.APPCONST;
import com.example.myreadproject8.databinding.ActivityReciteBinding;
import com.example.myreadproject8.greendao.entity.Recite;
import com.example.myreadproject8.greendao.service.ReciteService;
import com.example.myreadproject8.ui.activity.base.BaseActivity;
import com.example.myreadproject8.util.toast.ToastUtils;
import com.example.myreadproject8.util.utils.DateHelper;
public class ReciteActivity extends BaseActivity {
ActivityReciteBinding binding;
Recite recite;
ReciteService reciteService;
Context context;
@Override
protected void bindView() {
binding = ActivityReciteBinding.inflate(getLayoutInflater());
setContentView(binding.getRoot());
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
protected void initData(Bundle savedInstanceState) {
super.initData(savedInstanceState);
context = this;
recite = (Recite)getIntent().getSerializableExtra(APPCONST.Recite);
reciteService = new ReciteService();
binding.reciteDetailTitle.setText(recite.getReciteT());
binding.reciteDetailContent.setText("\t\t\t\t"+recite.getReciteContent());
binding.reciteDetailContent.setMovementMethod(ScrollingMovementMethod.getInstance());
binding.reciteDetailContent.setVerticalScrollBarEnabled(true);
binding.reciteDetailNums.setText("第\t"+recite.getReciteNums()+"\t次打开");
for(int i=0;i<recite.getReciteNum();i++){
if(i==0){
binding.rvReciteStatusFirst.setVisibility(View.VISIBLE);
if(recite.getFirstRecite())
binding.rvReciteStatusFirst.setImageResource(R.drawable.ic_item_category_download);
}else if(i==1){
binding.rvReciteStatusSecond.setVisibility(View.VISIBLE);
if(recite.getSecondRecite())
binding.rvReciteStatusSecond.setImageResource(R.drawable.ic_item_category_download);
}else if(i==2){
binding.rvReciteStatusThird.setVisibility(View.VISIBLE);
if(recite.getThirdRecite())
binding.rvReciteStatusThird.setImageResource(R.drawable.ic_item_category_download);
}else if(i==3){
binding.rvReciteStatusFourth.setVisibility(View.VISIBLE);
if(recite.getFourthRecite())
binding.rvReciteStatusFourth.setImageResource(R.drawable.ic_item_category_download);
}else if(i==4){
binding.rvReciteStatusFifth.setVisibility(View.VISIBLE);
if(recite.getFifthRecite())
binding.rvReciteStatusFifth.setImageResource(R.drawable.ic_item_category_download);
} else if(i==5){
binding.rvReciteStatusSixth.setVisibility(View.VISIBLE);
if(recite.getSixthRecite())
binding.rvReciteStatusSixth.setImageResource(R.drawable.ic_item_category_download);
}else if(i==6){
binding.rvReciteStatusSeventh.setVisibility(View.VISIBLE);
if(recite.getSeventhRecite())
binding.rvReciteStatusSeventh.setImageResource(R.drawable.ic_item_category_download);
}
}
}
@Override
protected void setUpToolbar(Toolbar toolbar) {
super.setUpToolbar(toolbar);
ActionBar actionBar = getSupportActionBar();
if(actionBar != null);{
actionBar.setDisplayHomeAsUpEnabled(false);
actionBar.setDisplayShowHomeEnabled(false);
}
setStatusBarColor(R.color.colorPrimary,true);
getSupportActionBar().setTitle("背诵");
getSupportActionBar().setSubtitle(recite.getBookName()+"——"+recite.getAuthor());
}
@Override
protected void initClick() {
super.initClick();
binding.actionHideRecite.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(binding.reciteDetailContent.getVisibility() == View.VISIBLE) {
binding.reciteDetailContent.setVisibility(View.INVISIBLE);
}else {
binding.reciteDetailContent.setVisibility(View.VISIBLE);
}
}
});
binding.actionHasRecite.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean[] flag = new boolean[7];
for(int i = 0;i < flag.length;i++){
flag[i] = false;
}
int [] diff = DateHelper.timeDiff(recite.getAddDate(),System.currentTimeMillis());
//按背诵时间段来设置计划完成情况
if(diff[2] > 20 && diff[1] < 1 && diff[0] < 1){
recite.setFirstRecite(true);//20分钟~1小时
recite.setReciteIndex(1);
flag[0] = true;
}else if(diff[1] >= 1 && diff[0] < 1 && diff[1] < 8){
if(recite.getReciteNum()>1) {
recite.setSecondRecite(true);//1小时~8小时
recite.setReciteIndex(2);
flag[1] = true;
}
}else if(diff[1] >= 8 && diff[0] < 1){
if(recite.getReciteNum()>2) {
recite.setThirdRecite(true);//8小时~1天
recite.setReciteIndex(3);
flag[2] = true;
}
}else if(diff[0] >= 1 && diff[0] < 2 ){
if(recite.getReciteNum()>3) {
recite.setFourthRecite(true);//1~2天
recite.setReciteIndex(4);
flag[3] = true;
}
}else if(diff[0] >= 2 && diff[0] < 6){
if(recite.getReciteNum()>4) {
recite.setFifthRecite(true);//2~36天
recite.setReciteIndex(5);
flag[4] = true;
}
}else if(diff[0] >= 6 && diff[0] < 30 ){
if(recite.getReciteNum()>5) {
recite.setSixthRecite(true);//6~30天
recite.setReciteIndex(6);
flag[5] = true;
}
}else if(diff[0] >= 30){
if(recite.getReciteNum()>6) {
recite.setSeventhRecite(true);//30天~
recite.setReciteIndex(7);
flag[6] = true;
}
}
reciteService.updateEntity(recite);
if(flag[0]||flag[1]||flag[2]||flag[3]||flag[4]||flag[5]||flag[6])
ToastUtils.showSuccess("背诵成功！");
else {
ToastUtils.showSuccess("本次背诵成功,但由于不在有效时段内,故不纳入统计,记忆有效时段为20min~1hour;1hour~8hour;8hour~1day;1day~2day;2day~30day;30day~");
}
finish();
}
});
binding.actionReciteOut.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
binding.actionCheckDetail.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(context, ReciteTableActivity.class);
intent.putExtra(APPCONST.Recite,recite);
context.startActivity(intent);
finish();
}
});
}
} |
package com.ifli.mbcp.domain;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "tbl_occupation")
public class Occupation extends GenericLookup implements Serializable
{
private static final long serialVersionUID = 8096690374300411306L;
@Override
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name = "occupationId", unique=true, nullable=false)
public Long getId()
{
return super.getId();
}
@Override
@Column(name = "occupationName", length = 50, nullable = false)
public String getName()
{
return super.getName();
}
@Override
@Column(name = "occupationDesc", nullable = true)
public String getDescription()
{
// TODO Auto-generated method stub
return super.getDescription();
}
}
|
/*
* created 18.06.2005
*
* Copyright 2009, ByteRefinery
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* $Id: TableSchemaOperation.java 3 2005-11-02 03:04:20Z csell $
*/
package com.byterefinery.rmbench.operations;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import com.byterefinery.rmbench.RMBenchPlugin;
import com.byterefinery.rmbench.model.schema.Schema;
import com.byterefinery.rmbench.model.schema.Table;
/**
* undoable operation that moves a table to another schema
*
* @author cse
*/
public class TableSchemaOperation extends RMBenchOperation {
private final Table table;
private final Schema oldSchema;
private Schema newSchema;
public TableSchemaOperation(Table table) {
super(Messages.Operation_ChangeTableSchema);
this.table = table;
this.oldSchema = table.getSchema();
}
public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
return setSchema(eventSource, oldSchema, newSchema);
}
public IStatus redo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
return setSchema(this, oldSchema, newSchema);
}
public IStatus undo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
return setSchema(this, newSchema, oldSchema);
}
private IStatus setSchema(Object eventSource, Schema fromSchema, Schema toSchema) {
table.setSchema(toSchema);
RMBenchPlugin.getEventManager().fireTableMoved(eventSource, fromSchema, table);
return Status.OK_STATUS;
}
public void execute(Object eventSource, Schema schema) {
newSchema = schema;
super.execute(eventSource);
}
}
|
package ru.krasview.tv;
import java.util.regex.Pattern;
import ru.krasview.kvlib.indep.AuthAccount;
import ru.krasview.kvlib.indep.HTTPClient;
import ru.krasview.kvlib.indep.consts.IntentConst;
import ru.krasview.kvlib.interfaces.OnLoadCompleteListener;
import ru.krasview.secret.ApiConst;
import android.app.Activity;
import android.os.Build;
import androidx.annotation.RequiresApi;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.webkit.CookieManager;
import android.webkit.CookieSyncManager;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.webkit.WebResourceRequest;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import ru.krasview.kvlib.indep.Parser;
public class SocialAuthActivity extends Activity {
WebView wv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.social_auth_activity);
wv = (WebView)findViewById(R.id.webView1);
wv.getSettings().setJavaScriptEnabled(true);
wv.getSettings().setUserAgentString("Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36 Kadu");
wv.setWebViewClient(new CustomWebViewClient());
if(getIntent().hasExtra("address")) {
wv.loadUrl(getIntent().getExtras().getString("address"));
} else {
finish();
}
}
@Override
protected void onResume() {
super.onResume();
HTTPClient.setContext(this);
}
private class CustomWebViewClient extends WebViewClient {
@SuppressWarnings("deprecation")
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
final Uri uri = Uri.parse(url);
return handleUri(view, uri);
}
@RequiresApi(Build.VERSION_CODES.N)
@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
final Uri uri = request.getUrl();
return handleUri(view, uri);
}
private boolean handleUri(WebView view, final Uri uri) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
CookieSyncManager.createInstance(getApplication());
}
CookieManager cookieManager = CookieManager.getInstance();
cookieManager.setAcceptCookie(true);
String cookie = cookieManager.getCookie("hlamer.ru");
Log.i("Krasview/Oauth", "cookie " + cookie + "; address: " + uri.getSchemeSpecificPart());
if(cookie!=null) {
String[] x = Pattern.compile(";").split(cookie);
String hash = "";
for (int i = 0; i < x.length; i++) {
if (x[i].contains("user=")) hash = x[i].replaceFirst("user=", "").trim();
}
Log.i("Krasview/Oauth", "hash " + hash);
if (hash == "") SocialAuthActivity.this.finish();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
prefs.edit().putString("pref_hash", hash).commit();
final String get_user_info = ApiConst.GET_USER_INFO;
HTTPClient.getXMLAsync(get_user_info, "hash="+hash ,new OnLoadCompleteListener() {
@Override
public void loadComplete(String result) {
}
@Override
public void loadComplete(String address, String result) {
if(address.equals(get_user_info)) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
Document mDocument = Parser.XMLfromString(result);
if (mDocument == null) { return; }
mDocument.normalizeDocument();
Node node = mDocument.getElementsByTagName("user").item(0);
Element user = (Element)node;
String name = user.getElementsByTagName("name").item(0).getTextContent();
String tv_hash = user.getElementsByTagName("tv_hash").item(0).getTextContent();
prefs.edit().putString("pref_login", name).putString("pref_hash_tv", tv_hash).commit();
//Log.i("Debug", "получен тв хеш с красвью " + tv_hash);
}
}
});
prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
prefs.edit().putString("pref_login", "")
.putString("pref_password", "")
.putInt("pref_auth_type", AuthAccount.AUTH_TYPE_KRASVIEW_SOCIAL)
.commit();
Intent a = new Intent(IntentConst.ACTION_MAIN_ACTIVITY);
startActivity(a);
SocialAuthActivity.this.setResult(SocialAuthActivity.RESULT_OK);
SocialAuthActivity.this.finish();
} else if(uri.getQueryParameter("error") != null) {
SocialAuthActivity.this.finish();
} else {
view.loadUrl(uri.getScheme() + ":" + uri.getSchemeSpecificPart());
}
return true;
}
};
}
|
package edu.uoc.arbolgenealogico.controller;
import java.sql.Date;
import java.util.Calendar;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
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.servlet.ModelAndView;
import edu.uoc.arbolgenealogico.pojo.Usuario;
import edu.uoc.arbolgenealogico.service.interfaces.IUsuarioService;
@Controller
public class HomeController {
@Autowired
@Qualifier("usuarioService")
private IUsuarioService userservice;
/**
* Método para el login del usuario
* @return ModelAndView
*/
@RequestMapping(value = {"/","/home"}, method = RequestMethod.GET)
public ModelAndView displayLogin() {
ModelAndView model = new ModelAndView("home");
Usuario user = new Usuario();
model.addObject("usuario", user);
return model;
}
/**
* Método de login que redirige a la página principal del usuario logeado
* @param usuario
* @return String
*/
@RequestMapping(value = {"/","/home"}, method = RequestMethod.POST)
public String executeLogin(@ModelAttribute("usuario") Usuario usuario) {
String model = null;
//comprobamos que el usuario existe en la bd
Usuario user = userservice.getByUsername(usuario.getUsername());
if(user!=null) {
//si existe, comprobamos su pass
if((user.getPass()).equals(usuario.getPass()) && (user.getOnline()==0)) {
//comprobamos si hay otro usuario online para cerrarle sesion
Usuario userOnline = userservice.getByOnline();
if(userOnline!=null) {
userOnline.setOnline(0);
userservice.update(userOnline);
}
//actualizar la base de datos cambiando online a 1 y la hora de conexion
user.setUltima_conexion(new Date(Calendar.getInstance().getTime().getTime()));
user.setOnline(1);
userservice.update(user);
model = "redirect:/usuarios/cuenta";
} else {
model = "error";
}
} else {
model = "error";
}
return model;
}
}
|
package com.testing.class9;
//Cat继承自Animal
// 子类 父类
public class Cat extends Animal {
//扩展的变量
public int claws=4;
public String voice="喵";
//修改继承自父类的变量
public String type="猫";
public final String TYPE_ANIMAL="猫猫";
public Cat(){
System.out.println("一只猫咪睁开了眼");
}
//扩展方法
public void play(){
System.out.println("猫会玩毛绒球");
}
//修改继承自父类的方法
public void drink(){
System.out.println("猫咪不爱喝水");
System.out.println("喝完再用动物的方法再喝一次");
super.drink();
}
//重载方法名，返回类型，参数列表必须与父类一致
// public String run() {
// return "";
// }
public void run(int speed){
System.out.println("猫咪跑的速度："+speed);
}
//子类不能重写父类的final方法
// public final void eat(){
// }
}
|
package com.mowitnow.businessObject;
public class Position {
private Cordonnee cordonnee;
private Orientation orientation;
public Position() {
super();
}
public Position(Cordonnee cordonnee, Orientation orientation) {
super();
this.cordonnee = cordonnee;
this.orientation = orientation;
}
public Position(int x, int y, char code) {
super();
this.cordonnee = new Cordonnee(x,y);
this.orientation = new Orientation(code);
}
public Cordonnee getCordonnee() {
return cordonnee;
}
public void setCordonnee(Cordonnee cordonnee) {
this.cordonnee = cordonnee;
}
public Orientation getOrientation() {
return orientation;
}
public void setOrientation(Orientation orientation) {
this.orientation = orientation;
}
public String toString(){
return cordonnee.toString()+" "+orientation.toString();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((cordonnee == null) ? 0 : cordonnee.hashCode());
result = prime * result + ((orientation == null) ? 0 : orientation.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Position other = (Position) obj;
if (cordonnee == null) {
if (other.cordonnee != null)
return false;
} else if (!cordonnee.equals(other.cordonnee))
return false;
if (orientation == null) {
if (other.orientation != null)
return false;
} else if (!orientation.equals(other.orientation))
return false;
return true;
}
}
|
package great_class30;
public class Problem_0088_MergeSortedArray {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int x = 0;
int y = 0;
int[] help = new int[m + n];
int index = 0;
while(x < m && y < n){
help[index++] = nums1[x] <= nums2[y] ? nums1[x++] : nums2[y++];
}
while(x < m){
help[index++] = nums1[x++];
}
while(y < n){
help[index++] = nums2[y++];
}
System.arraycopy(help, 0, nums1, 0, m + n);
}
}
|
package net.minecraft.world.biome;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IBlockAccess;
public class BiomeColorHelper {
private static final ColorResolver GRASS_COLOR = new ColorResolver() {
public int getColorAtPos(Biome biome, BlockPos blockPosition) {
return biome.getGrassColorAtPos(blockPosition);
}
};
private static final ColorResolver FOLIAGE_COLOR = new ColorResolver() {
public int getColorAtPos(Biome biome, BlockPos blockPosition) {
return biome.getFoliageColorAtPos(blockPosition);
}
};
private static final ColorResolver WATER_COLOR = new ColorResolver() {
public int getColorAtPos(Biome biome, BlockPos blockPosition) {
return biome.getWaterColor();
}
};
private static int getColorAtPos(IBlockAccess blockAccess, BlockPos pos, ColorResolver colorResolver) {
int i = 0;
int j = 0;
int k = 0;
for (BlockPos.MutableBlockPos blockpos$mutableblockpos : BlockPos.getAllInBoxMutable(pos.add(-1, 0, -1), pos.add(1, 0, 1))) {
int l = colorResolver.getColorAtPos(blockAccess.getBiome((BlockPos)blockpos$mutableblockpos), (BlockPos)blockpos$mutableblockpos);
i += (l & 0xFF0000) >> 16;
j += (l & 0xFF00) >> 8;
k += l & 0xFF;
}
return (i / 9 & 0xFF) << 16 | (j / 9 & 0xFF) << 8 | k / 9 & 0xFF;
}
public static int getGrassColorAtPos(IBlockAccess blockAccess, BlockPos pos) {
return getColorAtPos(blockAccess, pos, GRASS_COLOR);
}
public static int getFoliageColorAtPos(IBlockAccess blockAccess, BlockPos pos) {
return getColorAtPos(blockAccess, pos, FOLIAGE_COLOR);
}
public static int getWaterColorAtPos(IBlockAccess blockAccess, BlockPos pos) {
return getColorAtPos(blockAccess, pos, WATER_COLOR);
}
static interface ColorResolver {
int getColorAtPos(Biome param1Biome, BlockPos param1BlockPos);
}
}
/* Location: C:\Users\BSV\AppData\Local\Temp\Rar$DRa6216.20396\Preview\Preview.jar!\net\minecraft\world\biome\BiomeColorHelper.class
* Java compiler version: 8 (52.0)
* JD-Core Version: 1.1.3
*/ |
package gob.igm.ec;
import java.math.BigDecimal;
import javax.annotation.Generated;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;
@Generated(value="EclipseLink-2.5.2.v20140319-rNA", date="2018-10-03T11:38:06")
@StaticMetamodel(Ttarifario.class)
public class Ttarifario_ {
public static volatile SingularAttribute<Ttarifario, Short> idTarifa;
public static volatile SingularAttribute<Ttarifario, BigDecimal> valor;
public static volatile SingularAttribute<Ttarifario, BigDecimal> pesoMax;
public static volatile SingularAttribute<Ttarifario, BigDecimal> pesoMin;
public static volatile SingularAttribute<Ttarifario, Short> idZona;
} |
package com.hdc.seckill.config;
import com.hdc.seckill.pojo.User;
import com.hdc.seckill.service.IUserService;
import com.hdc.seckill.utils.CookieUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.thymeleaf.util.StringUtils;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @ClassName UserArgumentResolver
* @Description 实现user解析器
* @Author prog_evil
* @Date 2021/7/26 11:32 上午
* @Version 1.0
**/
@Component //需要注入
public class UserArgumentResolver implements HandlerMethodArgumentResolver {
@Autowired
private IUserService userService;
@Override
public boolean supportsParameter(MethodParameter methodParameter) {
Class<?> clazz = methodParameter.getParameterType();
return clazz == User.class;
}
@Override
public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
HttpServletRequest request = nativeWebRequest.getNativeRequest(HttpServletRequest.class);
HttpServletResponse response = nativeWebRequest.getNativeResponse(HttpServletResponse.class);
String ticket = CookieUtil.getCookieValue(request, "userTicket");
if(StringUtils.isEmpty(ticket)){
return null;
}
return userService.getUserByCookie(ticket,request,response);
}
}
|
package com.tencent.mm.g.a;
public final class l$a {
public String bGy;
}
|
package com.goodhealth.algorithm.reflex;
import com.goodhealth.comm.util.LoggerUtil;
import org.springframework.cache.annotation.Cacheable;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 动态获取类的信息以及动态调用对象的方法的功能称为Java语言的反射机制
* Java反射机制主要提供了以下功能：
* 在运行时判断任意一个对象所属的类；
* 在运行时构造任意一个类的对象；
* 在运行时判断任意一个类所具有的成员变量和方法；
* 在运行时调用任意一个对象的方法；
* 生成动态代理。
*/
public class Client {
public static void main(String[] args) throws Exception {
new Client().getterAndSetter();
}
public Class<?> createClass(){
// 通过类名构造Class对象 最安全高效
Class PC = Person.class;
// 通过Class类的静态方法来构造Class对象
try {
Class Pc = Class.forName("com.goodhealth.algorithm.reflex.Person");
} catch (ClassNotFoundException e) {
LoggerUtil.error("找不到这个类{}",e);
}
//通过类的实例构造Class对象
Class pc = new Person().getClass();
// 特殊类的情况
Class bc = Boolean.TYPE; // boolean.class
/**
* 类似的还有int double long byte short float char void
*/
return PC;
}
public void getClassInfo(){
Class pclass = createClass();
/** 使用Java反射，你可以在运行时检查Java类。检查类是使用反射时经常做的第一件事情。
* 从类中可以获取以下信息：
*(1) 类名(2) 类修饰符 (public, private, synchronized等)(3) 包信息
*(4) 父类(5) 实现的接口(6) 构造函数
*(7) 方法(8) 字段(9) 注解
*/
// 获取类的全限定名 com.goodhealth.algorithm.reflex.Person
pclass.getName();
// 获取类的类名 Person
pclass.getSimpleName();
// 获取类的修饰词
int modifiers = pclass.getModifiers();
java.lang.reflect.Modifier.isPublic(modifiers);
// 获取类的包信息
Package pack = pclass.getPackage();
pack.getName();
// 获取父类的Class
Class superClass = pclass.getSuperclass();
// 获取实现的接口列表 注意只返回此类实现的的接口，其父类、子类的接口都不在内
Class[] interfaces = pclass.getInterfaces();
// 获取构造方法 构造方法需是public的 私有的不能拿到
Constructor[] constructors = pclass.getConstructors();
// 获取方法
Method[] methods = pclass.getMethods();
// 获取字段
Field[] fields = pclass.getFields();
// 获取注解
Annotation[] annotations = pclass.getAnnotations();
}
public Constructor useConstructor() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Class pclass = createClass();
// 获取所有构造方法 构造方法需是public的
// 私有的不拿能到除非使用getDeclaredConstructors()--> getDeclaredXXX不限定修饰词
Constructor[] constructors = pclass.getConstructors();
// 获取指定的构造方法
Constructor withArgConstructor = pclass.getConstructor(Integer.class,String.class);
Constructor noArgConstructor = pclass.getConstructor();
// 根据构造方法获取它的参数类型
/** parameterTypes[0] class java.lang.Integer */
Class[] parameterTypes = withArgConstructor.getParameterTypes();
// 使用构造方法实例对象
Person person = (Person) withArgConstructor.newInstance(18,"Mr.Wang");
person.getName(); // Mr.Wang
return withArgConstructor;
}
public void useField() throws NoSuchFieldException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IntrospectionException {
Class pclass = createClass();
Person person = (Person) useConstructor().newInstance(18,"DangDang");
// 获取类的所有属性Field对象 必须为public修饰词 除非使用getDeclaredFields
// 私有的不拿能到除非使用getDeclaredConstructors()--> getDeclaredXXX不限定修饰词
Field[] fieldsPublic = pclass.getFields();
Field[] fieldsNoLimit = pclass.getDeclaredFields();
/** fieldsNoLimit[0]-----> private java.lang.String com.goodhealth.algorithm.reflex.Person.name */
// 获取类指定属性Field
// Field fieldPublic = pclass.getField("age");
Field fieldNoLimit = pclass.getDeclaredField("name");
// 获取Field 字段名称
fieldNoLimit.getName();
// 获取Field字段类型
fieldNoLimit.getType();
// 获取、设置Field字段的值
fieldNoLimit.setAccessible(true); // 关闭了访问检查 暴力破解private字段的封装性
String name = (String)fieldNoLimit.get(person); // Mr.Wang
fieldNoLimit.set(person,"MR.Wang"); // {"name":"MR.Wang","age":18}
}
public void useMethod() throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class pclass = createClass();
Person person = (Person) useConstructor().newInstance(18,"Mr.Wang");
// 获取类中的方法
Method[] methodsPublic = pclass.getMethods();
Method[] methodsNoLimit = pclass.getDeclaredMethods();
Method methodNoLimit = pclass.getDeclaredMethod("doSome");
Method setName = pclass.getDeclaredMethod("setName",String.class);
Method staMethod = pclass.getDeclaredMethod("staMethod");
// 获取类中方法的参数
Class[] paramType = pclass.getDeclaredMethod("setName",String.class).getParameterTypes();
/** paramType[0] class java.lang.String */
// 获取类中方法的返回类型
Class returnType = pclass.getDeclaredMethod("getName").getReturnType();
/** returnType class java.lang.String */
// 通过反射调用类中的方法
methodNoLimit.invoke(person);
setName.invoke(person,"MS.Wang");
// 当调用的是静态方法时，实例传null值即可
staMethod.setAccessible(true); // 关闭了访问检查 暴力破解private方法的封装性
staMethod.invoke(null);
}
public void getterAndSetter() throws IntrospectionException {
Class pclass = createClass();
/** 利用 Field + PropertyDescriptor 获取类的get/set方法 */
Field[] fieldsNoLimit = pclass.getDeclaredFields();
for (Field field :fieldsNoLimit) {
PropertyDescriptor pd = new PropertyDescriptor(field.getName(), pclass);
Method getMethod = pd.getReadMethod(); // 获得get方法
Method setMethod = pd.getWriteMethod(); // 获得set方法
}
/** 利用 BeanInfo + PropertyDescriptor 获取类的get/set方法 */
BeanInfo beanInfo = Introspector.getBeanInfo(pclass);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName(); // 获取属性名
Class type = property.getPropertyType(); // 获取属性类型
Method setter = property.getWriteMethod(); // 获得set方法
Method getter = property.getReadMethod(); // 获得get方法
}
}
}
|
package com.example.thirdsdk;
import java.util.HashMap;
import java.util.LinkedHashMap;
import org.json.JSONException;
import org.json.JSONObject;
import com.example.thirdsdk.util.FucUtil;
import com.example.thirdsdk.util.JsonParser;
import com.iflytek.cloud.ErrorCode;
import com.iflytek.cloud.InitListener;
import com.iflytek.cloud.RecognizerListener;
import com.iflytek.cloud.RecognizerResult;
import com.iflytek.cloud.SpeechConstant;
import com.iflytek.cloud.SpeechError;
import com.iflytek.cloud.SpeechRecognizer;
import com.iflytek.cloud.ui.RecognizerDialog;
import com.iflytek.cloud.ui.RecognizerDialogListener;
import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.Toast;
/**
* Created by ouyangshen on 2017/12/18.
*/
public class VoiceRecognizeActivity extends AppCompatActivity implements OnClickListener {
private final static String TAG = VoiceRecognizeActivity.class.getSimpleName();
// 语音听写对象
private SpeechRecognizer mRecognize;
// 语音听写UI
private RecognizerDialog mRecognizeDialog;
// 用HashMap存储听写结果
private HashMap<String, String> mRecognizeResults = new LinkedHashMap<String, String>();
private EditText et_recognize_text;
private SharedPreferences mSharedPreferences;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_voice_recognize);
et_recognize_text = findViewById(R.id.et_recognize_text);
findViewById(R.id.btn_recognize_start).setOnClickListener(this);
findViewById(R.id.btn_recognize_stop).setOnClickListener(this);
findViewById(R.id.btn_recognize_cancel).setOnClickListener(this);
findViewById(R.id.btn_recognize_stream).setOnClickListener(this);
findViewById(R.id.btn_recognize_setting).setOnClickListener(this);
mSharedPreferences = getSharedPreferences(VoiceSettingsActivity.PREFER_NAME, Activity.MODE_PRIVATE);
// 初始化识别无UI识别对象，使用SpeechRecognizer对象，可根据回调消息自定义界面；
mRecognize = SpeechRecognizer.createRecognizer(this, mInitListener);
// 初始化听写Dialog，如果只使用有UI听写功能，无需创建SpeechRecognizer
// 使用UI听写功能，请将assets下文件拷贝到项目中
mRecognizeDialog = new RecognizerDialog(this, mInitListener);
}
@Override
protected void onDestroy() {
super.onDestroy();
// 退出时释放连接
mRecognize.cancel();
mRecognize.destroy();
}
@Override
public void onClick(View v) {
int ret; // 函数调用返回值
if (v.getId() == R.id.btn_recognize_setting) { // 进入参数设置页面
Intent intent = new Intent(this, VoiceSettingsActivity.class);
intent.putExtra("type", VoiceSettingsActivity.XF_RECOGNIZE);
startActivity(intent);
} else if (v.getId() == R.id.btn_recognize_start) { // 开始听写。如何判断一次听写结束：OnResult isLast=true 或者 onError
et_recognize_text.setText(null); // 清空显示内容
mRecognizeResults.clear();
// 设置参数
resetParam();
boolean isShowDialog = mSharedPreferences.getBoolean("show_dialog", true);
if (isShowDialog) {
// 显示听写对话框
mRecognizeDialog.setListener(mRecognizeDialogListener);
mRecognizeDialog.show();
showTip("请开始说话………");
} else {
// 不显示听写对话框
ret = mRecognize.startListening(mRecognizeListener);
if (ret != ErrorCode.SUCCESS) {
showTip("听写失败,错误码：" + ret);
} else {
showTip("请开始说话…");
}
}
} else if (v.getId() == R.id.btn_recognize_stop) { // 停止听写
mRecognize.stopListening();
showTip("停止听写");
} else if (v.getId() == R.id.btn_recognize_cancel) { // 取消听写
mRecognize.cancel();
showTip("取消听写");
} else if (v.getId() == R.id.btn_recognize_stream) { // 音频流识别
et_recognize_text.setText(null);// 清空显示内容
mRecognizeResults.clear();
// 设置参数
resetParam();
// 设置音频来源为外部文件
mRecognize.setParameter(SpeechConstant.AUDIO_SOURCE, "-1");
// 也可以像以下这样直接设置音频文件路径识别（要求设置文件在sdcard上的全路径）：
// mRecognize.setParameter(SpeechConstant.AUDIO_SOURCE, "-2");
// mRecognize.setParameter(SpeechConstant.ASR_SOURCE_PATH, "sdcard/XXX/XXX.pcm");
ret = mRecognize.startListening(mRecognizeListener);
if (ret != ErrorCode.SUCCESS) {
showTip("识别失败,错误码：" + ret);
} else {
byte[] audioData = FucUtil.readAudioFile(this, "retcognize_est.wav");
if (null != audioData) {
showTip("开始音频流识别");
// 一次（也可以分多次）写入音频文件数据，数据格式必须是采样率为8KHz或16KHz（本地识别只支持16K采样率，云端都支持），位长16bit，单声道的wav或者pcm
// 写入8KHz采样的音频时，必须先调用setParameter(SpeechConstant.SAMPLE_RATE, "8000")设置正确的采样率
// 注：当音频过长，静音部分时长超过VAD_EOS将导致静音后面部分不能识别
mRecognize.writeAudio(audioData, 0, audioData.length);
mRecognize.stopListening();
} else {
mRecognize.cancel();
showTip("读取音频流失败");
}
}
}
}
// 初始化监听器
private InitListener mInitListener = new InitListener() {
@Override
public void onInit(int code) {
Log.d(TAG, "SpeechRecognizer init() code = " + code);
if (code != ErrorCode.SUCCESS) {
showTip("初始化失败，错误码：" + code);
}
}
};
// 听写监听器
private RecognizerListener mRecognizeListener = new RecognizerListener() {
@Override
public void onBeginOfSpeech() {
// 此回调表示：sdk内部录音机已经准备好了，用户可以开始语音输入
showTip("开始说话");
}
@Override
public void onError(SpeechError error) {
// 错误码：10118(您没有说话)，可能是录音机权限被禁，需要提示用户打开应用的录音权限。
// 如果使用本地功能（语记）需要提示用户开启语记的录音权限。
showTip(error.getPlainDescription(true));
}
@Override
public void onEndOfSpeech() {
// 此回调表示：检测到了语音的尾端点，已经进入识别过程，不再接受语音输入
showTip("结束说话");
}
@Override
public void onResult(RecognizerResult results, boolean isLast) {
Log.d(TAG, results.getResultString());
printResult(results);
if (isLast) {
// TODO 最后的结果
}
}
@Override
public void onVolumeChanged(int volume, byte[] data) {
showTip("当前正在说话，音量大小：" + volume);
Log.d(TAG, "返回音频数据：" + data.length);
}
@Override
public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
// 以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
// 若使用本地能力，会话id为null
// if (SpeechEvent.EVENT_SESSION_ID == eventType) {
// String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
// Log.d(TAG, "session id =" + sid);
// }
}
};
private void printResult(RecognizerResult results) {
String text = JsonParser.parseIatResult(results.getResultString());
String sn;
try {
JSONObject resultJson = new JSONObject(results.getResultString());
sn = resultJson.optString("sn");
} catch (JSONException e) {
e.printStackTrace();
return;
}
mRecognizeResults.put(sn, text);
StringBuilder resultBuffer = new StringBuilder();
for (String key : mRecognizeResults.keySet()) {
resultBuffer.append(mRecognizeResults.get(key));
}
et_recognize_text.setText(resultBuffer.toString());
et_recognize_text.setSelection(et_recognize_text.length());
}
// 听写UI监听器
private RecognizerDialogListener mRecognizeDialogListener = new RecognizerDialogListener() {
public void onResult(RecognizerResult results, boolean isLast) {
printResult(results);
}
// 识别回调错误
public void onError(SpeechError error) {
showTip(error.getPlainDescription(true));
}
};
private void showTip(String str) {
Toast.makeText(this, str, Toast.LENGTH_LONG).show();
}
//参数设置
public void resetParam() {
// 清空参数
mRecognize.setParameter(SpeechConstant.PARAMS, null);
// 设置听写引擎。TYPE_LOCAL表示本地，TYPE_CLOUD表示云端，TYPE_MIX 表示混合
mRecognize.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
// 设置返回结果格式
mRecognize.setParameter(SpeechConstant.RESULT_TYPE, "json");
String language = mSharedPreferences.getString("recognize_language_preference", "mandarin");
if (language.equals("en_us")) { // 设置语言
mRecognize.setParameter(SpeechConstant.LANGUAGE, "en_us");
} else {
mRecognize.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
// 设置语言区域
mRecognize.setParameter(SpeechConstant.ACCENT, language);
}
// 设置语音前端点:静音超时时间，即用户多长时间不说话则当做超时处理
mRecognize.setParameter(SpeechConstant.VAD_BOS, mSharedPreferences.getString("recognize_vadbos_preference", "4000"));
// 设置语音后端点:后端点静音检测时间，即用户停止说话多长时间内即认为不再输入， 自动停止录音
mRecognize.setParameter(SpeechConstant.VAD_EOS, mSharedPreferences.getString("recognize_vadeos_preference", "1000"));
// 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
mRecognize.setParameter(SpeechConstant.ASR_PTT, mSharedPreferences.getString("recognize_punc_preference", "1"));
// 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
// 注：AUDIO_FORMAT参数语记需要更新版本才能生效
mRecognize.setParameter(SpeechConstant.AUDIO_FORMAT, "wav");
mRecognize.setParameter(SpeechConstant.ASR_AUDIO_PATH, getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS).toString() + "/msc/recognize.wav");
}
}
|
package imp;
import service.Person;
/**
* 状态抽象类
* @date 2019/2/21
*/
public abstract class PersonStatus {
public Person person = null;
/**
* 到时间需要做的事情
*/
public abstract void doSth(Integer hour);
/**
* 调整状态
*/
public abstract String computeStatus();
}
|
package laioffer.june25th;
import common.Utils;
import java.util.LinkedList;
import java.util.List;
/**
* Created by mengzhou on 6/25/17.
*/
public class SpiralOrderTraversal {
public List<Integer> spiral(int[][] matrix) {
List<Integer> res = new LinkedList<>();
helper(matrix, res, new boolean[matrix.length][matrix[0].length], 0, 0, 0);
return res;
}
// 0: right, 1:down, 2:left, 3:up
public void helper(int[][] m, List<Integer> list, boolean[][] visited, int x, int y, int dir) {
if(x < 0 || x >= m.length || y < 0 || y >= m[0].length) return;
if(visited[x][y]) return;
list.add(m[x][y]);
visited[x][y] = true;
if(dir == 0) {
if(y + 1 < m[0].length && !visited[x][y + 1]) helper(m, list, visited, x, y + 1, 0);
else helper(m, list, visited, x + 1, y, 1);
} else if(dir == 1) {
if(x + 1 < m.length && !visited[x + 1][y]) helper(m, list, visited, x + 1, y, 1);
else helper(m, list, visited, x, y - 1, 2);
} else if(dir == 2) {
if(y - 1 >= 0 && !visited[x][y - 1]) helper(m, list, visited, x, y - 1, 2);
else helper(m, list, visited, x - 1, y, 3);
} else if(dir == 3) {
if(x - 1 >= 0 && !visited[x - 1][y]) helper(m, list, visited, x - 1, y, 3);
else helper(m, list, visited, x, y + 1, 0);
}
}
public static void main(String[] args) {
SpiralOrderTraversal app = new SpiralOrderTraversal();
Utils.printList(app.spiral(new int[][]{
{1, 2, 3},
{5, 6, 7},
{9, 10,11},
{13,14,15}}));
}
} |
package modul6.ab04;
public class Team {
private String name;
private int score;
private int goal;
private int counterGoal;
private int id;
Team(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getGoal() {
return goal;
}
public void setGoal(int goal) {
this.goal = goal;
}
public int getCounterGoal() {
return counterGoal;
}
public void setCounterGoal(int counterGoal) {
this.counterGoal = counterGoal;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
void addPoint(int point) {
this.score += point;
}
void addGoal(int goal) {
this.goal += goal;
}
void addCounterGoal( int counterGoal) {
this.counterGoal += counterGoal;
}
} |
package com.ehootu.census.model;
import java.util.Date;
/**
* @Author: KongXiaoPing
* @Date: 2017/12/28 10:27
* @Description: 户籍登记表
*/
public class CensusRegister {
private String id;
/**
* 曾用名
*/
private String usedName;
/**
* 家庭住址
*/
private String homeAddress;
/**
* 民族
*/
private String nationality;
/**
* 教育程度
*/
private String education;
/**
* 申请变更内容
*/
private String applicationForChange;
/**
* 同步标记：0 未同步，1 已同步
*/
private Integer isSync;
/**
* 微信外网同步标记：0 未同步，1 已同步
*/
private Integer syncSign;
/**
* 姓名
*/
private String name;
/**
* 出生日期
*/
private Date birthDate;
/**
* 身份证号
*/
private String idNumber;
/**
* 现在户口所在地
*/
private String currentCensusRegisterPlace;
/**
* 性别（0 女 1男）
*/
private String gender;
/**
* 配偶姓名
*/
private String spouseName;
/**
* 结婚时间
*/
private Date marriedTime;
/**
* 新生儿姓名
*/
private String newbornName;
/**
* 新生儿性别（0 女 1男）
*/
private String newbornGender;
/**
* 新生儿出生时间
*/
private Date newbornBirthDate;
/**
* 与死亡人员关系
*/
private String relation;
/**
* 注销人姓名
*/
private String cancelledPersonName;
/**
* 注销人出生时间
*/
private Date cancelledPersonBirthDate;
/**
* 注销人身份证号
*/
private String cancelledPersonIdNumber;
/**
* 注销人死亡原因
*/
private String cancelledPersonCauseDeath;
/**
* 附件表关联id
*/
private String attachmentId;
/**
* 户籍类型 4 夫妻投靠 5 新生儿 6 户籍注销 7 购房迁户 8 户籍信息变更
*/
private Integer currentCensusType;
/**
* 状态：0-迁入入户;1-迁出2-迁移3-注销
*/
private Integer currentCensusStatus;
/**
* 登录用户（操作人）
*/
private String userId;
/**
* 提交时间
*/
private Date submitTime;
/**
* 警员id
*/
private String policeId;
/**
* 所属派出所
*/
private String policeStation;
/**
* 所属警务室
*/
private String policeOffice;
/**
* 所属工作站
*/
private String workStation;
/**
* 所属行政区划
*/
private String administrativeDivision;
/**
* 操作来源（1 微信端 2 户政大厅 保留字段，目前不用）
*/
private String operationType;
/**
* 创建时间
*/
private Date createTime;
/**
* 修改时间
*/
private Date updateTime;
/**
* 删除标志：0、未删除，1、已删除
*/
private Integer deleteFlag;
public CensusRegister() {
}
public CensusRegister(InputCensus inputCensus) {
this.name = inputCensus.getName();
this.birthDate = inputCensus.getBirthDate();
this.idNumber = inputCensus.getIdNumber();
this.currentCensusRegisterPlace = inputCensus.getCurrentCensusRegisterPlace();
this.gender = inputCensus.getGender();
this.spouseName = inputCensus.getSpouseName();
this.marriedTime = inputCensus.getMarriedTime();
this.newbornName = inputCensus.getNewbornName();
this.newbornGender = inputCensus.getNewbornGender();
this.relation = inputCensus.getRelation();
this.cancelledPersonName = inputCensus.getCancelledPersonName();
this.cancelledPersonBirthDate = inputCensus.getCancelledPersonBirthDate();
this.cancelledPersonIdNumber = inputCensus.getCancelledPersonIdNumber();
this.cancelledPersonCauseDeath = inputCensus.getCancelledPersonCauseDeath();
this.newbornBirthDate = inputCensus.getNewbornBirthDate();
this.attachmentId = inputCensus.getAttachmentId();
this.currentCensusType = inputCensus.getCurrentCensusType();
this.currentCensusStatus = inputCensus.getCurrentCensusStatus();
this.userId = inputCensus.getUserId();
this.submitTime = inputCensus.getSubmitTime();
this.policeId = inputCensus.getPoliceId();
this.policeStation = inputCensus.getPoliceStation();
this.policeOffice = inputCensus.getPoliceOffice();
this.workStation = inputCensus.getWorkStation();
this.administrativeDivision = inputCensus.getAdministrativeDivision();
this.operationType = inputCensus.getOperationType();
this.usedName = inputCensus.getUsedName();
this.homeAddress = inputCensus.getHomeAddress();
this.nationality = inputCensus.getNationality();
this.education = inputCensus.getEducation();
this.applicationForChange = inputCensus.getApplicationForChange();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id == null ? null : id.trim();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name == null ? null : name.trim();
}
public String getUsedName() {
return usedName;
}
public void setUsedName(String usedName) {
this.usedName = usedName == null ? null : usedName.trim();
}
public Date getBirthDate() {
return birthDate;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
public String getIdNumber() {
return idNumber;
}
public void setIdNumber(String idNumber) {
this.idNumber = idNumber == null ? null : idNumber.trim();
}
public String getCurrentCensusRegisterPlace() {
return currentCensusRegisterPlace;
}
public void setCurrentCensusRegisterPlace(String currentCensusRegisterPlace) {
this.currentCensusRegisterPlace = currentCensusRegisterPlace == null ? null : currentCensusRegisterPlace.trim();
}
public String getHomeAddress() {
return homeAddress;
}
public void setHomeAddress(String homeAddress) {
this.homeAddress = homeAddress == null ? null : homeAddress.trim();
}
public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality == null ? null : nationality.trim();
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender == null ? null : gender.trim();
}
public String getSpouseName() {
return spouseName;
}
public void setSpouseName(String spouseName) {
this.spouseName = spouseName == null ? null : spouseName.trim();
}
public String getEducation() {
return education;
}
public void setEducation(String education) {
this.education = education == null ? null : education.trim();
}
public Date getMarriedTime() {
return marriedTime;
}
public void setMarriedTime(Date marriedTime) {
this.marriedTime = marriedTime;
}
public String getNewbornName() {
return newbornName;
}
public void setNewbornName(String newbornName) {
this.newbornName = newbornName == null ? null : newbornName.trim();
}
public String getNewbornGender() {
return newbornGender;
}
public void setNewbornGender(String newbornGender) {
this.newbornGender = newbornGender == null ? null : newbornGender.trim();
}
public Date getNewbornBirthDate() {
return newbornBirthDate;
}
public void setNewbornBirthDate(Date newbornBirthDate) {
this.newbornBirthDate = newbornBirthDate;
}
public String getRelation() {
return relation;
}
public void setRelation(String relation) {
this.relation = relation == null ? null : relation.trim();
}
public String getCancelledPersonName() {
return cancelledPersonName;
}
public void setCancelledPersonName(String cancelledPersonName) {
this.cancelledPersonName = cancelledPersonName == null ? null : cancelledPersonName.trim();
}
public Date getCancelledPersonBirthDate() {
return cancelledPersonBirthDate;
}
public void setCancelledPersonBirthDate(Date cancelledPersonBirthDate) {
this.cancelledPersonBirthDate = cancelledPersonBirthDate;
}
public String getCancelledPersonIdNumber() {
return cancelledPersonIdNumber;
}
public void setCancelledPersonIdNumber(String cancelledPersonIdNumber) {
this.cancelledPersonIdNumber = cancelledPersonIdNumber == null ? null : cancelledPersonIdNumber.trim();
}
public String getCancelledPersonCauseDeath() {
return cancelledPersonCauseDeath;
}
public void setCancelledPersonCauseDeath(String cancelledPersonCauseDeath) {
this.cancelledPersonCauseDeath = cancelledPersonCauseDeath == null ? null : cancelledPersonCauseDeath.trim();
}
public String getApplicationForChange() {
return applicationForChange;
}
public void setApplicationForChange(String applicationForChange) {
this.applicationForChange = applicationForChange == null ? null : applicationForChange.trim();
}
public String getAttachmentId() {
return attachmentId;
}
public void setAttachmentId(String attachmentId) {
this.attachmentId = attachmentId == null ? null : attachmentId.trim();
}
public Integer getCurrentCensusType() {
return currentCensusType;
}
public void setCurrentCensusType(Integer currentCensusType) {
this.currentCensusType = currentCensusType;
}
public Integer getCurrentCensusStatus() {
return currentCensusStatus;
}
public void setCurrentCensusStatus(Integer currentCensusStatus) {
this.currentCensusStatus = currentCensusStatus;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId == null ? null : userId.trim();
}
public Date getSubmitTime() {
return submitTime;
}
public void setSubmitTime(Date submitTime) {
this.submitTime = submitTime;
}
public String getPoliceId() {
return policeId;
}
public void setPoliceId(String policeId) {
this.policeId = policeId == null ? null : policeId.trim();
}
public String getPoliceStation() {
return policeStation;
}
public void setPoliceStation(String policeStation) {
this.policeStation = policeStation == null ? null : policeStation.trim();
}
public String getPoliceOffice() {
return policeOffice;
}
public void setPoliceOffice(String policeOffice) {
this.policeOffice = policeOffice == null ? null : policeOffice.trim();
}
public String getWorkStation() {
return workStation;
}
public void setWorkStation(String workStation) {
this.workStation = workStation == null ? null : workStation.trim();
}
public String getAdministrativeDivision() {
return administrativeDivision;
}
public void setAdministrativeDivision(String administrativeDivision) {
this.administrativeDivision = administrativeDivision == null ? null : administrativeDivision.trim();
}
public String getOperationType() {
return operationType;
}
public void setOperationType(String operationType) {
this.operationType = operationType == null ? null : operationType.trim();
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public Integer getDeleteFlag() {
return deleteFlag;
}
public void setDeleteFlag(Integer deleteFlag) {
this.deleteFlag = deleteFlag;
}
public Integer getIsSync() {
return isSync;
}
public void setIsSync(Integer isSync) {
this.isSync = isSync;
}
public Integer getSyncSign() {
return syncSign;
}
public void setSyncSign(Integer syncSign) {
this.syncSign = syncSign;
}
} |
package co.nos.noswallet.ui.settings.setRepresentative;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.Nullable;
import android.support.v4.app.FragmentActivity;
import android.support.v7.widget.Toolbar;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;
import android.widget.PopupMenu;
import android.widget.TextView;
import javax.inject.Inject;
import co.nos.noswallet.R;
import co.nos.noswallet.persistance.currency.CryptoCurrency;
import co.nos.noswallet.ui.common.ActivityWithComponent;
import co.nos.noswallet.ui.common.BaseDialogFragment;
import co.nos.noswallet.ui.common.WindowControl;
/**
* Settings main screen
*/
public class SetRepresentativeDialogFragment extends BaseDialogFragment implements SetRepresentativeView {
public static final String CURRENCY = "CURRENCY";
public static String TAG = SetRepresentativeDialogFragment.class.getSimpleName();
@Nullable
private CryptoCurrency cryptoCurrency;
private EditText representativeInput;
private TextView errorLabel;
private Handler handler;
@Inject
SetRepresentativePresenter presenter;
public static SetRepresentativeDialogFragment newInstance(CryptoCurrency currency) {
Bundle args = new Bundle();
SetRepresentativeDialogFragment fragment = new SetRepresentativeDialogFragment();
args.putSerializable(CURRENCY, currency);
fragment.setArguments(args);
return fragment;
}
public static void openRepresentativeFragment(CryptoCurrency cryptoCurrency, FragmentActivity activity) {
if (activity instanceof WindowControl) {
SetRepresentativeDialogFragment dialog = SetRepresentativeDialogFragment.newInstance(cryptoCurrency);
dialog.show(((WindowControl) activity).getFragmentUtility().getFragmentManager(),
SetRepresentativeDialogFragment.TAG);
// make sure that dialog is not null
((WindowControl) activity).getFragmentUtility().getFragmentManager().executePendingTransactions();
}
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
cryptoCurrency = getSerializableArgument(CURRENCY);
handler = new Handler(Looper.getMainLooper());
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
if (getActivity() instanceof ActivityWithComponent) {
((ActivityWithComponent) getActivity()).getActivityComponent().inject(this);
}
View view = inflater.inflate(R.layout.fragment_change_representative, container, false);
setStatusBar();
setupToolbar(view);
presenter.attachView(this);
representativeInput = view.findViewById(R.id.representative_input);
errorLabel = view.findViewById(R.id.representative_label_error);
TextView saveButton = view.findViewById(R.id.representative_save);
saveButton.setOnClickListener(v -> {
hideKeyboard();
String text = representativeInput.getText().toString().trim();
presenter.saveRepresentativeClicked(cryptoCurrency, text);
});
presenter.requestCachedRepresentative(cryptoCurrency);
return view;
}
private void setupToolbar(View view) {
Toolbar toolbar = view.findViewById(R.id.dialog_appbar);
if (toolbar != null) {
final SetRepresentativeDialogFragment window = this;
TextView title = view.findViewById(R.id.dialog_toolbar_title);
title.setText(R.string.change_representative);
toolbar.setNavigationOnClickListener(v1 -> window.dismiss());
}
}
@Override
public void clearRepresentativeError() {
errorLabel.setText("");
}
@Override
public void showRepresentativeError(int stringRes) {
errorLabel.setTextColor(getResources().getColor(R.color.red));
errorLabel.setText(stringRes);
}
@Override
public void showRepresentativeSavedAndExit(int stringRes) {
errorLabel.setTextColor(getResources().getColor(R.color.green));
errorLabel.setText(stringRes);
handler.postDelayed(this::dismiss, 400);
}
@Override
public void onRepresentativeReceived(String previousRepresentative) {
representativeInput.setText(previousRepresentative);
representativeInput.setSelection(previousRepresentative.length());
}
@Override
public void dismiss() {
super.dismiss();
handler.removeCallbacksAndMessages(null);
}
}
|
package com.tencent.tencentmap.mapsdk.a;
public interface hp {
void a();
void a(hz hzVar);
void b(hz hzVar);
}
|
package com.kingcar.rent.pro.adapter.base;
import android.view.View;
/**
* Created by cwj on 2018/3/21.
*/
public interface RecyItemClickListener {
void onItemClick(View view, int position);
}
|
package com.zoupeng.community.controller;
import com.alibaba.fastjson.JSONObject;
import com.zoupeng.community.entity.Message;
import com.zoupeng.community.entity.Page;
import com.zoupeng.community.entity.User;
import com.zoupeng.community.service.MessageService;
import com.zoupeng.community.service.UserService;
import com.zoupeng.community.util.CommunityConstant;
import com.zoupeng.community.util.HostHolder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.util.HtmlUtils;
import java.util.*;
@Controller
public class MessageController implements CommunityConstant {
@Autowired
MessageService messageService;
@Autowired
HostHolder holder;
@Autowired
UserService userService;
//私信列表
@RequestMapping(path = "/conversation/list", method = RequestMethod.GET)
public String getLetterList(Model model, Page page) {
User user = holder.getUser();
//设置分页信息
page.setLimit(5);
page.setPath("/conversation/list");
page.setRows(messageService.findConversationCount(user.getId()));
//查询会话列表
List<Message> conversationList = messageService.findConversations(
user.getId(), page.getOffset(), page.getLimit());
//Map是一个会话的信息，包括未读数量，消息总数，消息的所有属性
List<Map<String, Object>> conversationVoList = new ArrayList<>();
if (conversationList != null) {
for (Message message : conversationList) {
Map<String, Object> conversationVo = new HashMap<>();
conversationVo.put("conversation", message);
//当前会话未读消息数量
conversationVo.put("unreadCount", messageService.findLetterUnreadCount(user.getId(), message.getConversationId()));
//当前会话总共消息数量，包括历史
conversationVo.put("letterCount", messageService.findLetterCount(message.getConversationId()));
int targetId = user.getId() == message.getFromId() ? message.getToId() : message.getFromId();
conversationVo.put("target", userService.findUserById(targetId));
conversationVoList.add(conversationVo);
}
}
model.addAttribute("conversationVoList", conversationVoList);
//查询未读消息的数量
int allUnreadCount = messageService.findLetterUnreadCount(user.getId(), null);
model.addAttribute("allUnreadCount", allUnreadCount);
int noticeUnreadCount = messageService.findUnreadNoticeCount(user.getId(), null);
model.addAttribute("noticeUnreadCount", noticeUnreadCount);
return "/site/letter";
}
//获取某个会话的全部内容
@RequestMapping(value = "/conversation/detail/{conversationId}", method = RequestMethod.GET)
public String getLetterDetail(@PathVariable("conversationId") String conversationId, Page page, Model model) {
//分页消息
page.setLimit(5);
page.setPath("/conversation/detail/" + conversationId);
page.setRows(messageService.findLetterCount(conversationId));
List<Message> letterList = messageService.findLetters(conversationId, page.getOffset(), page.getLimit());
//每一条Message对应一个发送人fromUser
List<Map<String, Object>> letterVoList = new ArrayList<>();
if (letterList != null) {
for (Message message : letterList) {
Map<String, Object> letterVo = new HashMap<>();
letterVo.put("letter", message);
letterVo.put("fromUser", userService.findUserById(message.getFromId()));
letterVoList.add(letterVo);
}
}
model.addAttribute("letterVoList", letterVoList);
//查询私信目标
model.addAttribute("target", getLetterTarget(conversationId));
//将消息设置为已读
List<Integer> ids = getLetterIds(letterList);
if (!ids.isEmpty()) {
messageService.readMessage(ids);
}
return "/site/letter-detail";
}
private List<Integer> getLetterIds(List<Message> letterList) {
List<Integer> ids = new ArrayList<>();
if (letterList != null) {
for (Message message : letterList) {
//我是接收者且消息是未读
if (holder.getUser().getId() == message.getToId() && message.getStatus() == 0) {
ids.add(message.getId());
}
}
}
return ids;
}
//获取目标用户，会话中，除自己外的就是会话目标
private User getLetterTarget(String conversationId) {
String[] ids = conversationId.split("_");
int id0 = Integer.parseInt(ids[0]);
int id1 = Integer.parseInt(ids[1]);
if (holder.getUser().getId() == id0) {
return userService.findUserById(id1);
} else return userService.findUserById(id0);
}
@RequestMapping(path = "/letter/send", method = RequestMethod.POST)
@ResponseBody
//将消息发给谁
public Map<String, String> sentLetter(String toName, String content) {
User target = userService.findUserByName(toName);
Map<String, String> map = new HashMap<>();
if (target == null) {
map.put("code", "1");
map.put("msg", "目标用户不存在");
return map;
}
Message message = new Message();
message.setFromId(holder.getUser().getId());
message.setToId(target.getId());
if (message.getFromId() < target.getId()) {
message.setConversationId(message.getFromId() + "_" + target.getId());
} else {
message.setConversationId(target.getId() + "_" + message.getFromId());
}
message.setContent(content);
message.setCreateTime(new Date());
messageService.addMessage(message);
map.put("code", "0");
return map;
}
@RequestMapping(path = "/notice/list", method = RequestMethod.GET)
public String getNoticeList(Model model) {
User user = holder.getUser();
//查询评论类通知
Message message = messageService.findLatestNotice(user.getId(), TOPIC_COMMENT);
Map<String, Object> messageVo = new HashMap<>();
messageVo.put("message", message);
if (message != null) {
//反转义
String content = HtmlUtils.htmlUnescape(message.getContent());
HashMap<String, Object> data = JSONObject.parseObject(content, HashMap.class);
messageVo.put("user", userService.findUserById((Integer) data.get("userId")));
messageVo.put("entityType", data.get("entityType"));
messageVo.put("entityId", data.get("entityId"));
messageVo.put("postId", data.get("postId"));
int count = messageService.findNoticeCount(user.getId(), TOPIC_COMMENT);
messageVo.put("count", count);
int unreadCount = messageService.findUnreadNoticeCount(user.getId(), TOPIC_COMMENT);
messageVo.put("unreadCount", unreadCount);
}
model.addAttribute("commentNotice", messageVo);
//查询点赞类通知
message = messageService.findLatestNotice(user.getId(), TOPIC_LIKE);
messageVo = new HashMap<>();
messageVo.put("message", message);
if (message != null) {
//反转义
String content = HtmlUtils.htmlUnescape(message.getContent());
HashMap<String, Object> data = JSONObject.parseObject(content, HashMap.class);
messageVo.put("user", userService.findUserById((Integer) data.get("userId")));
messageVo.put("entityType", data.get("entityType"));
messageVo.put("entityId", data.get("entityId"));
messageVo.put("postId", data.get("postId"));
int count = messageService.findNoticeCount(user.getId(), TOPIC_LIKE);
messageVo.put("count", count);
int unreadCount = messageService.findUnreadNoticeCount(user.getId(), TOPIC_LIKE);
messageVo.put("unreadCount", unreadCount);
}
model.addAttribute("likeNotice", messageVo);
//查询关注类通知
message = messageService.findLatestNotice(user.getId(), TOPIC_FOLLOW);
messageVo = new HashMap<>();
messageVo.put("message", message);
if (message != null) {
//反转义
String content = HtmlUtils.htmlUnescape(message.getContent());
HashMap<String, Object> data = JSONObject.parseObject(content, HashMap.class);
messageVo.put("user", userService.findUserById((Integer) data.get("userId")));
messageVo.put("entityType", data.get("entityType"));
messageVo.put("entityId", data.get("entityId"));
int count = messageService.findNoticeCount(user.getId(), TOPIC_FOLLOW);
messageVo.put("count", count);
int unreadCount = messageService.findUnreadNoticeCount(user.getId(), TOPIC_FOLLOW);
messageVo.put("unreadCount", unreadCount);
}
model.addAttribute("followNotice", messageVo);
//查询未读消息数量
int letterUnreadCount = messageService.findLetterUnreadCount(user.getId(), null);
model.addAttribute("letterUnreadCount", letterUnreadCount);
int noticeUnreadCount = messageService.findUnreadNoticeCount(user.getId(), null);
model.addAttribute("noticeUnreadCount", noticeUnreadCount);
return "/site/notice";
}
@RequestMapping(path = "/notice/detail/{topic}", method = RequestMethod.GET)
public String getNoticeDetail(@PathVariable("topic") String topic, Model model, Page page) {
User user = holder.getUser();
page.setLimit(5);
page.setPath("/notice/detail/" + topic);
page.setRows(messageService.findNoticeCount(user.getId(), topic));
List<Message> noticeList = messageService.findNotices(user.getId(), topic, page.getOffset(), page.getLimit());
List<Map<String, Object>> noticeVoList = new ArrayList<>();
if (noticeList != null) {
for (Message message : noticeList) {
Map<String, Object> noticeVo = new HashMap<>();
//通知
noticeVo.put("notice", message);
//内容
String content = HtmlUtils.htmlUnescape(message.getContent());
Map<String, Object> data = JSONObject.parseObject(content, HashMap.class);
noticeVo.put("user", userService.findUserById((Integer) data.get("userId")));
noticeVo.put("entityType", data.get("entityType"));
noticeVo.put("entityId", data.get("entityId"));
noticeVo.put("postId", data.get("post_id"));
//系统用户的名字
noticeVo.put("fromUser", userService.findUserById(message.getFromId()));
noticeVoList.add(noticeVo);
}
model.addAttribute("noticeVoList", noticeVoList);
}
//设置已读
List<Integer> ids = getLetterIds(noticeList);
if (!ids.isEmpty()) {
messageService.readMessage(ids);
}
return "/site/notice-detail";
}
}
|
/**
*
*/
package com.wonders.quartz.cocc.model.xml;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import com.wonders.quartz.cocc.model.vo.CoccListVo;
import com.wonders.quartz.cocc.model.vo.CoccReportVo;
/**
* @ClassName: CoccReportXml
* @Description: TODO(这里用一句话描述这个类的作用)
* @author zhoushun
* @date 2013年12月10日 下午2:31:33
*
*/
@XmlRootElement(name = "root")
public class CoccReportXml {
@XmlAttribute(name = "type")
public String type="coccMetroWeekReport";
@XmlAttribute(name = "date")
public String date= new java.text.SimpleDateFormat("yyyy-MM-dd").format(new java.util.Date());
@XmlElement(name = "list")
public CoccListVo list;
}
|
package org.slevin.common;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
@Entity
public class Mahalle {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
String name;
String itemId;
@ManyToOne
private Semt semt;
Boolean complated;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getItemId() {
return itemId;
}
public void setItemId(String itemId) {
this.itemId = itemId;
}
public Boolean getComplated() {
return complated;
}
public void setComplated(Boolean complated) {
this.complated = complated;
}
}
|
package vlad.fp.lib;
import java.util.function.Function;
import java.util.function.Supplier;
public abstract class Option<T> {
public static <T> Option<T> none() {
return None();
}
public static <T> Option<T> some(T value) {
return Some(value);
}
private enum Type {
NONE,
SOME,
}
private Option() {
// private constructor
}
public T orElse(Supplier<T> elseCase) {
return match(elseCase, x -> x);
}
public <R> Option<R> flatMap(Function<T, Option<R>> f) {
return match(Option::none, f);
}
public <R> Option<R> map(Function<T, R> f) {
return flatMap(x -> Option.some(f.apply(x)));
}
protected abstract Type getType();
private <R> R matchT(
Function<None<T>, R> noneCase,
Function<Some<T>, R> someCase
) {
switch (getType()) {
case NONE:
return noneCase.apply(asNone());
case SOME:
return someCase.apply(asSome());
default:
throw new AssertionError();
}
}
public <R> R match(
Supplier<R> noneCase,
Function<T, R> someCase
) {
return matchT(
none -> noneCase.get(),
some -> someCase.apply(some.value)
);
}
private static final class None<T> extends Option<T> {
private static final None instance = new None();
@Override
protected Type getType() {
return Type.NONE;
}
@Override
protected None<T> asNone() {
return this;
}
}
@SuppressWarnings("unchecked")
private static <T> None<T> None() {
return None.instance;
}
protected None<T> asNone() {
throw new AssertionError();
}
private static final class Some<T> extends Option<T> {
private final T value;
private Some(T value) {
this.value = value;
}
@Override
protected Type getType() {
return Type.SOME;
}
@Override
protected Some<T> asSome() {
return this;
}
}
private static <T> Some<T> Some(T value) {
return new Some<>(value);
}
protected Some<T> asSome() {
throw new AssertionError();
}
}
|
execute(des, src, registers, memory) {
int desSize = 0;
int srcSize = 0;
int sizeOfHex = 4;
Calculator c = new Calculator(registers, memory);
if(des.isRegister()) {
desSize = registers.getBitSize(des);
}
else{
desSize = memory.getBitSize(des);
}
if(src.isRegister()) {
srcSize = registers.getBitSize(src);
}
else{
srcSize = memory.getBitSize(src);
if( srcSize == 0) {
srcSize = registers.getBitSize(des);
}
}
String sourceReg = "";
String desStr = "";
String srcStr = "";
///end of defining sizes///
if(des.isRegister()) {
if(desSize == srcSize && (srcSize == 64 || srcSize == 128 ) && src.isRegister() ) {
desStr = registers.get(des);
srcStr = registers.get(src);
sourceReg = executeMultiply(des, src, registers, memory, c, desSize, srcSize, desStr, srcStr, sizeOfHex);
}
if((srcSize == 64 || srcSize == 128 ) && src.isMemory() ) {
desStr = registers.get(des);
srcStr = memory.read(src, desSize);
sourceReg = executeMultiply(des, src, registers, memory, c, desSize, srcSize, desStr, srcStr, sizeOfHex);
}
registers.set(des, sourceReg);
}
if(des.isMemory()) {
if(desSize == srcSize && ( srcSize == 64 || srcSize == 128 ) && src.isRegister() ) {
desStr = memory.read(des, desSize);
srcStr = registers.get(src);
sourceReg = executeMultiply(des, src, registers, memory, c, desSize, srcSize, desStr, srcStr, sizeOfHex);
}
}
}
String executeMultiply(des, src, registers, memory, c, desSize, srcSize, desStr, srcStr, sizeOfHex){
String resultingMultiply = "";
String[] arrBi = new String[12];
for(int x = 0; x < srcSize / 4; x = x + sizeOfHex) {
boolean isNegSrc = false;
boolean isNegDes = false;
String strDes = desStr.substring(x, x + sizeOfHex);
String strSrc = srcStr.substring(x, x + sizeOfHex);
BigInteger destination;
BigInteger source;
if(c.binaryZeroExtend(new BigInteger(strSrc, 16).toString(2), sizeOfHex * 4).charAt(0) == '1') {
source = new BigInteger(c.hexZeroExtend(negate(des, src, registers, memory, c, sizeOfHex, strSrc), sizeOfHex), 16).negate();
isNegSrc = true;
}
else{
source = new BigInteger(strSrc, 16);
}
if(c.binaryZeroExtend(new BigInteger(strDes, 16).toString(2), sizeOfHex * 4).charAt(0) == '1') {
destination = new BigInteger(c.hexZeroExtend(negate(des, src, registers, memory, c, sizeOfHex, strDes), sizeOfHex), 16).negate();
isNegDes = true;
}
else{
destination = new BigInteger(strDes, 16);
}
destination = destination.multiply(source);
if(destination.toString(16).charAt(0) == '-') {
destination = new BigInteger(c.hexZeroExtend(negate(des, src, registers, memory, c, sizeOfHex, destination.toString(16).substring(1)), sizeOfHex), 16);
}
if(isNegDes && !isNegSrc || !isNegDes && isNegSrc) {
arrBi[((x + sizeOfHex)/ sizeOfHex) - 1] = (c.hexFExtend(destination.toString(16), sizeOfHex * 2));
}
else{
arrBi[((x + sizeOfHex)/ sizeOfHex) - 1] = (c.hexZeroExtend(destination.toString(16), sizeOfHex * 2));
}
}
if(desSize == 64)
resultingMultiply = arrBi[0].substring(4, 8) + arrBi[1].substring(4, 8) + arrBi[2].substring(4, 8) + arrBi[3].substring(4, 8);
else
resultingMultiply = arrBi[0].substring(4, 8) + arrBi[1].substring(4, 8) + arrBi[2].substring(4, 8) + arrBi[3].substring(4, 8) + resultingMultiply + arrBi[4].substring(4, 8) + arrBi[5].substring(4, 8) + arrBi[6].substring(4, 8) + arrBi[7].substring(4, 8);
return resultingMultiply;
}
String negate(des, src, registers, memory, c, sizeOfHex, desStr){
String source = "";
int borrow = 0;
String destination = c.hexToBinaryString(desStr, sizeOfHex);
destination = c.binaryZeroExtend(destination, sizeOfHex * 4);
StringBuilder sb = new StringBuilder(destination);
for(int x = 0; x < destination.length(); x++) {
if(sb.charAt(x) == '1') {
sb.setCharAt(x, '0');
}
else{
sb.setCharAt(x, '1');
}
}
return new BigInteger(sb.toString(), 2).add(new BigInteger("1")).toString(16);
}
|
package pl.gabinetynagodziny.officesforrent.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import javax.persistence.*;
import java.util.List;
import java.util.Set;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long roleId;
private String name;
@ManyToMany(mappedBy = "roles")
List<User> users;
}
|
package com.geektech.androidthree.ui.onBoard;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import com.geektech.androidthree.R;
import com.geektech.androidthree.ui.main.MainActivity;
import com.rd.PageIndicatorView;
public class OnBoardActivity extends AppCompatActivity {
public static void start(Context context) {
context.startActivity(new Intent(context, OnBoardActivity.class));
}
private ViewPager viewPager;
private Button nextBtn, skipBtn;
private PageIndicatorView pageIndicatorView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_on_board);
nextBtn = findViewById(R.id.next_button_onboard);
skipBtn = findViewById(R.id.skip_button_onboard);
pageIndicatorView = findViewById(R.id.pageIndicatorView);
pageIndicatorView.setCount(4);
pageIndicatorView.setSelection(2);
viewPager = findViewById(R.id.onboard_viewpager);
viewPager.setAdapter(new OnBoardAdapter());
viewPagerListener();
buttonClickListener();
}
private void buttonClickListener() {
nextBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (viewPager.getCurrentItem() < 3) {
int i = viewPager.getCurrentItem();
viewPager.setCurrentItem(++i);
} else {
MainActivity.start(OnBoardActivity.this);
finish();
}
}
});
skipBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
MainActivity.start(OnBoardActivity.this);
finish();
}
});
}
private void viewPagerListener() {
viewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@Override
public void onPageSelected(int position) {
pageIndicatorView.setSelection(position);
if (position == 3) {
nextBtn.setText("Начать");
skipBtn.setVisibility(View.GONE);
} else {
nextBtn.setText("Далее");
skipBtn.setVisibility(View.VISIBLE);
}
}
@Override
public void onPageScrollStateChanged(int state) {
}
});
}
}
|
package com.codepath.nytimes.activities;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.app.SearchManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.databinding.DataBindingUtil;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.ConnectivityManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.support.customtabs.CustomTabsIntent;
import android.support.design.widget.Snackbar;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.SearchView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.Toast;
import com.borax12.materialdaterangepicker.date.DatePickerDialog;
import com.codepath.nytimes.R;
import com.codepath.nytimes.Utils.Constants;
import com.codepath.nytimes.adapters.ArticleAdapter;
import com.codepath.nytimes.adapters.EndlessRecyclerViewScrollListener;
import com.codepath.nytimes.adapters.ItemClickSupport;
import com.codepath.nytimes.databinding.ActivityArticleListBinding;
import com.codepath.nytimes.models.Article;
import com.codepath.nytimes.models.Response;
import com.codepath.nytimes.network.ArticleApiInterface;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import okhttp3.OkHttpClient;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class ArticleListActivity extends AppCompatActivity implements
DatePickerDialog.OnDateSetListener {
private ActivityArticleListBinding binding;
private ArticleAdapter articleAdapter;
private List<Article> articleList;
private EditText etDateRange;
private SharedPreferences filterPreferences;
private SharedPreferences.Editor editor;
private static Integer PAGE_NUMBER = 0;
private static String QUERY = "";
private static String TEMP_QUERY = "";
private boolean isArtsChecked = false;
private boolean isSportsChecked = false;
private boolean isFashionChecked = false;
private int sortOrder = 0;
private String begin_date = "";
private String end_date = "";
Handler handler = new Handler();
private boolean isFirst = true;
SearchView searchView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = DataBindingUtil.setContentView(this, R.layout.activity_article_list);
setSupportActionBar(binding.toolbar);
getSupportActionBar().setDisplayShowHomeEnabled(true);
getSupportActionBar().setLogo(R.mipmap.nytimes);
getSupportActionBar().setDisplayUseLogoEnabled(true);
articleList = new ArrayList<>();
articleAdapter = new ArticleAdapter(articleList);
binding.rvList.setAdapter(articleAdapter);
StaggeredGridLayoutManager mLayoutManager = new StaggeredGridLayoutManager(3, StaggeredGridLayoutManager.VERTICAL);
binding.rvList.setLayoutManager(mLayoutManager);
ItemClickSupport.addTo(binding.rvList).setOnItemClickListener(
(RecyclerView recyclerView, int position, View v) -> {
Article article = articleList.get(position);
String url = article.getWebUrl();
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.ic_action_name);
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, article.getWebUrl());
int requestCode = 100;
PendingIntent pendingIntent = PendingIntent.getActivity(ArticleListActivity.this,
requestCode,
intent,
PendingIntent.FLAG_UPDATE_CURRENT);
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
builder.setToolbarColor(ContextCompat.getColor(ArticleListActivity.this, R.color.colorPrimary));
builder.setActionButton(bitmap, "Share Link", pendingIntent, true);
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(ArticleListActivity.this, Uri.parse(url));
});
filterPreferences = getSharedPreferences("filter_settings", Context.MODE_PRIVATE);
editor = filterPreferences.edit();
QUERY = "";
TEMP_QUERY = "";
if (!isNetworkAvailable(this)) {
Snackbar.make(binding.swipeContainer, R.string.not_connected, Snackbar.LENGTH_INDEFINITE).setAction("Retry",
v -> {
this.recreate();
}).show();
}
binding.rvList.addOnScrollListener(new EndlessRecyclerViewScrollListener((StaggeredGridLayoutManager) mLayoutManager) {
@Override
public void onLoadMore(int page, int totalItemsCount) {
PAGE_NUMBER++;
fetchArticles(QUERY);
}
});
binding.swipeContainer.setOnRefreshListener(() -> {
PAGE_NUMBER = 0;
fetchArticles(QUERY);
});
binding.swipeContainer.setColorSchemeResources(R.color.colorPrimary,
R.color.colorAccent);
Intent intent = getIntent();
if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
String query = intent.getStringExtra(SearchManager.QUERY);
QUERY = query;
TEMP_QUERY = query;
isFirst = true;
fetchArticles(query);
} else {
editor.clear().apply();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_article_list, menu);
SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
searchView = (SearchView) menu.findItem(R.id.action_search).getActionView();
searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
searchView.setIconifiedByDefault(false);
searchView.setQueryHint("Search articles..");
searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
PAGE_NUMBER = 0;
QUERY = query;
TEMP_QUERY = query;
fetchArticles(query);
searchView.clearFocus();
return true;
}
@Override
public boolean onQueryTextChange(String newText) {
TEMP_QUERY = newText;
return false;
}
});
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
switch (id) {
case R.id.action_filter:
showFilterDialog();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
public void showFilterDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
LayoutInflater inflater = this.getLayoutInflater();
final View dialogView = inflater.inflate(R.layout.filter_dialog, null);
dialogBuilder.setView(dialogView);
CheckBox checkBoxArts = (CheckBox) dialogView.findViewById(R.id.checkBoxArts);
CheckBox checkBoxFashion = (CheckBox) dialogView.findViewById(R.id.checkBoxFashion);
CheckBox checkBoxSports = (CheckBox) dialogView.findViewById(R.id.checkBoxSports);
Spinner oldNewSpinner = (Spinner) dialogView.findViewById(R.id.oldNewSpinner);
etDateRange = (EditText) dialogView.findViewById(R.id.etDateRange);
checkBoxArts.setChecked(filterPreferences.getBoolean("isArtsChecked", false));
checkBoxFashion.setChecked(filterPreferences.getBoolean("isFashionChecked", false));
checkBoxSports.setChecked(filterPreferences.getBoolean("isSportsChecked", false));
oldNewSpinner.setSelection(filterPreferences.getInt("sortOrder", 0));
if (!TextUtils.isEmpty(filterPreferences.getString("begin_date", ""))) {
String tempDateRange = filterPreferences.getString("begin_date", "") + '-' + filterPreferences.getString("end_date", "");
etDateRange.setText(tempDateRange);
}
dialogBuilder.setTitle("Filter");
dialogBuilder.setPositiveButton("Apply", (DialogInterface dialog, int whichButton) -> {
isArtsChecked = checkBoxArts.isChecked();
editor.putBoolean("isArtsChecked", isArtsChecked);
isFashionChecked = checkBoxFashion.isChecked();
editor.putBoolean("isFashionChecked", isFashionChecked);
isSportsChecked = checkBoxSports.isChecked();
System.out.println("isSportsChecked " + isSportsChecked);
editor.putBoolean("isSportsChecked", isSportsChecked);
sortOrder = oldNewSpinner.getSelectedItemPosition();
editor.putInt("sortOrder", sortOrder);
if (!TextUtils.isEmpty(etDateRange.getText().toString())) {
String temp_date[] = etDateRange.getText().toString().split("-");
if (temp_date.length == 2) {
begin_date = temp_date[0];
end_date = temp_date[1];
}
} else {
begin_date = "";
end_date = "";
}
editor.putString("begin_date", begin_date);
editor.putString("end_date", end_date);
editor.apply();
if (!TextUtils.isEmpty(TEMP_QUERY) || !TextUtils.isEmpty(QUERY)) {
PAGE_NUMBER = 0;
if (!TextUtils.isEmpty(TEMP_QUERY)) {
QUERY = TEMP_QUERY;
}
fetchArticles(QUERY);
}
});
dialogBuilder.setNegativeButton("Cancel", (DialogInterface dialog, int whichButton) -> {
});
AlertDialog b = dialogBuilder.create();
b.show();
etDateRange.setOnClickListener(v -> {
Calendar now = Calendar.getInstance();
DatePickerDialog dpd = DatePickerDialog.newInstance(
ArticleListActivity.this,
now.get(Calendar.YEAR),
now.get(Calendar.MONTH),
now.get(Calendar.DAY_OF_MONTH)
);
dpd.show(getFragmentManager(), "Datepickerdialog");
});
}
public void fetchArticles(final String query) {
if (PAGE_NUMBER == 0) {
articleList.clear();
articleAdapter.notifyDataSetChanged();
}
if (TextUtils.isEmpty(query)) {
binding.swipeContainer.setRefreshing(false);
return;
}
OkHttpClient httpClient = new OkHttpClient();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.client(httpClient)
.addConverterFactory(GsonConverterFactory.create())
.build();
Map<String, String> params = new HashMap<>();
params.put("q", query);
params.put("page", String.valueOf(PAGE_NUMBER));
params.put("api_key", Constants.API_KEY);
int sort = filterPreferences.getInt("sortOrder", 0);
String begin_date = filterPreferences.getString("begin_date", "");
String end_date = filterPreferences.getString("end_date", "");
String news_desk = filterPreferences.getString("news_desk", "");
Log.d("NyTimes", "sort: " + sort + " begin_date:" + begin_date + " end_date:" + end_date + "news_desk:" + news_desk);
if (sort != 0) {
String sortString = "newest";
if (sort == 2) {
sortString = "oldest";
}
params.put("sort", sortString);
}
if (!TextUtils.isEmpty(begin_date)) {
params.put("begin_date", begin_date);
}
if (!TextUtils.isEmpty(end_date)) {
params.put("end_date", end_date);
}
if (isArtsChecked || isSportsChecked || isFashionChecked) {
String temp = "news_desk:(";
if (isArtsChecked) {
temp += " Arts";
}
if (isSportsChecked) {
temp += " Sports";
}
if (isFashionChecked) {
temp += " Fashion%20%26%20Style";
}
temp += ")";
Log.d(Constants.TAG, "fetchArticles: " + temp);
params.put("fq", temp);
}
ArticleApiInterface apiService = retrofit.create(ArticleApiInterface.class);
int delay;
if(isFirst) {
delay = 0;
} else {
delay = 1000;
}
handler.postDelayed(() -> {
isFirst = false;
Call<Response> call = apiService.getArticles(params);
call.enqueue(new Callback<Response>() {
@Override
public void onResponse(Call<Response> call, retrofit2.Response<Response> response) {
Log.d(Constants.TAG, "onResponse: " + response.code());
if (response.code() == 200) {
Response r = response.body();
articleList.addAll(r.getDocument().getArticles());
articleAdapter.notifyDataSetChanged();
binding.swipeContainer.setRefreshing(false);
} else {
Toast.makeText(ArticleListActivity.this, "status code" + response.code(), Toast.LENGTH_SHORT).show();
}
}
@Override
public void onFailure(Call<Response> call, Throwable t) {
Log.e("DEBUG", "Network call failed ");
Toast.makeText(ArticleListActivity.this, "Network call failed", Toast.LENGTH_SHORT).show();
}
});
}, delay);
}
public boolean isNetworkAvailable(final Context context) {
final ConnectivityManager connectivityManager = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
return connectivityManager.getActiveNetworkInfo() != null && connectivityManager.getActiveNetworkInfo().isConnected();
}
@Override
public void onDateSet(DatePickerDialog view, int year, int monthOfYear, int dayOfMonth, int yearEnd, int monthOfYearEnd, int dayOfMonthEnd) {
String day = Integer.toString(dayOfMonth);
if (day.length() == 1) {
day = "0" + day;
}
String month = Integer.toString(++monthOfYear);
if (month.length() == 1) {
month = "0" + month;
}
String dayEnd = Integer.toString(dayOfMonthEnd);
if (dayEnd.length() == 1) {
dayEnd = "0" + dayEnd;
}
String monthEnd = Integer.toString(++monthOfYearEnd);
if (monthEnd.length() == 1) {
monthEnd = "0" + monthEnd;
}
String date = Integer.toString(year) + month + day + "-" + yearEnd + monthEnd + dayEnd;
etDateRange.setText(date);
}
public void clearDate(View view) {
etDateRange.setText("");
}
public void onDateSet(View view) {
Calendar now = Calendar.getInstance();
DatePickerDialog dpd = DatePickerDialog.newInstance(
ArticleListActivity.this,
now.get(Calendar.YEAR),
now.get(Calendar.MONTH),
now.get(Calendar.DAY_OF_MONTH)
);
dpd.show(getFragmentManager(), "Datepickerdialog");
}
}
|
package www.movieapp.adapter;
import android.content.Context;
import android.content.Intent;
import android.media.Image;
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.squareup.picasso.Picasso;
import java.util.List;
import www.movieapp.Constant.Constant;
import www.movieapp.MovieDetailedView;
import www.movieapp.R;
import www.movieapp.module.MovieDB;
/**
* Created by amy on 26/10/17.
*/
public class MovieListAdapter extends RecyclerView.Adapter<MovieListAdapter.MovieViewHolder> {
List<MovieDB> movieDBList;
Context context;
public MovieListAdapter(Context context, List<MovieDB> movieDBList) {
this.context = context;
this.movieDBList = movieDBList;
}
@Override
public MovieViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.activity_movie_adapter, parent, false);
MovieViewHolder movieViewHolder = new MovieViewHolder(view);
return movieViewHolder;
}
@Override
public void onBindViewHolder(MovieViewHolder holder, int position) {
MovieDB movieDB = movieDBList.get(position);
final String moviePoster = movieDB.getMoviePosters();
final String movieTitle = movieDB.getMovieTitle();
final String movieSynopsis = movieDB.getMovieDescription();
final String movieReleaseDate = movieDB.getMovieReleaseDate();
final String movieRating = movieDB.getMovieRating();
final String movieId = movieDB.getMovieId();
Picasso.with(context).load(Constant.POSTER_PATH + moviePoster).into(holder.imageViewMoviePoster);
holder.imageViewMoviePoster.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intentMovieDetailedView=new Intent();
intentMovieDetailedView.putExtra(Constant.MOVIE_ID,movieId);
intentMovieDetailedView.putExtra(Constant.MOVIE_TITLE,movieTitle);
intentMovieDetailedView.putExtra(Constant.MOVIE_IMAGE_POSTER,moviePoster);
intentMovieDetailedView.putExtra(Constant.MOVIE_SYNOPSIS,movieSynopsis);
intentMovieDetailedView.putExtra(Constant.MOVIE_RATING,movieRating);
intentMovieDetailedView.putExtra(Constant.MOVIE_ReleaseDate,movieReleaseDate);
intentMovieDetailedView.setClass(context, MovieDetailedView.class);
context.startActivity(intentMovieDetailedView);
}
});
}
@Override
public int getItemCount() {
return movieDBList.size();
}
class MovieViewHolder extends RecyclerView.ViewHolder {
ImageView imageViewMoviePoster;
public MovieViewHolder(View itemView) {
super(itemView);
imageViewMoviePoster = (ImageView) itemView.findViewById(R.id.imageView_movie_poster);
}
}
}
|
package com.choa.blackList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;
import com.choa.member.MemberDAO;
import com.choa.member.MemberDTO;
import com.choa.blackList.BlackDAO;
import com.choa.util.MemberPageMaker;
@Service
public class BlackService {
@Autowired
private BlackDAO blackDAO;
//신고 글 작성
public int singoWrite(BlackDTO blackDTO) throws Exception {
return blackDAO.singoWrite(blackDTO);
}
//신고 글 삭제
public int singoDelete(String sid)throws Exception{
return blackDAO.singoDelete(sid);
}
//회원정보열람
public void memberInfo(int curPage, int perPage, Model model, int type) throws Exception{
int totalCount = blackDAO.memberCount(type);
MemberPageMaker mPageMaker = new MemberPageMaker();
mPageMaker.setType(type);
mPageMaker.setCurPage(curPage);
mPageMaker.setPerPage(perPage);
mPageMaker.makeRow();
List<MemberDTO> ar = null;
try{
mPageMaker.makePage(totalCount);
ar = blackDAO.memberInfo(mPageMaker);
}catch (Exception e){
e.printStackTrace();
}
model.addAttribute("memberInfo", ar);
model.addAttribute("paging", mPageMaker);
}
//신고 글 보기
public BlackDTO singoView(String sid, Model model) throws Exception{
BlackDTO blackDTO = blackDAO.singoView(sid);
model.addAttribute("blackDTO",blackDTO);
return blackDTO;
}
//블랙멤버 정보보기
public MemberDTO blackmView(String id, Model model) throws Exception{
MemberDTO memberDTO = blackDAO.blackmView(id);
model.addAttribute("blackm",memberDTO);
return memberDTO;
}
//회원수정
public int blackmUpdate(MemberDTO memberDTO)throws Exception{
return blackDAO.blackmUpdate(memberDTO);
}
}
|
package com.tencent.mm.plugin.wallet_payu.create.a;
import com.tencent.mm.ab.l;
import com.tencent.mm.plugin.wallet_payu.security_question.model.d;
import com.tencent.mm.ui.MMActivity;
import com.tencent.mm.wallet_core.d.g;
import com.tencent.mm.wallet_core.d.i;
class c$3 extends g {
final /* synthetic */ c pEC;
c$3(c cVar, MMActivity mMActivity, i iVar) {
this.pEC = cVar;
super(mMActivity, iVar);
}
public final boolean r(Object... objArr) {
this.uXK.a(new d(), true);
return false;
}
public final boolean d(int i, int i2, String str, l lVar) {
if (!(lVar instanceof d) || i != 0 || i2 != 0) {
return false;
}
this.pEC.jfZ.putParcelableArrayList("key_security_question_list", ((d) lVar).pGk);
return true;
}
public final boolean m(Object... objArr) {
return false;
}
}
|
package com.levi9.taster.core.jpa;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;
import org.springframework.stereotype.Repository;
import com.levi9.taster.core.Question;
/**
* JPA Repository for {@link JpaQuestion}.
*
* @author r.horvat
*/
@Repository
public interface QuestionJpaRepository extends JpaRepository<JpaQuestion, Long>, QueryDslPredicateExecutor<JpaQuestion> {
/**
* Returns list of questions with given category ID.
*
* @param id of category
* @return list of questions
*/
List<Question> findQuestionsByCategoryId(Long id);
/**
* Returns list of questions with given fixed test template ID.
*
* @param id of fixed test template
* @return list of questions
*/
List<Question> findQuestionsByFixedTestTemplatesId(Long id);
}
|
package com.example.demo;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ApplicationTest {
@Autowired
private BeanProperties beanProperties;
@Test
public void getBean() {
//Assert.assertArrayEquals(beanProperties.getName(),"SpringBootLearning");
}
}
|
package com.sunny.pccollection.config.springmvc;
import com.sunny.token.TokenService;
import com.sunny.token.module.UserInfoDto;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Objects;
@Component
public class MvcInterceptorAdapter extends HandlerInterceptorAdapter {
@Resource(name = "localTokenService")
TokenService tokenService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (Objects.isNull(tokenService)) {
throw new Exception("请在启动类中添加扫描com.sunny.token");
}
// TODO 这里传入request和 response 参数并不合理，需要把request和response做的操作移动到这边来
UserInfoDto userInfoDto = tokenService.authToken(request, response);
if (!Objects.isNull(userInfoDto)) {
return false;
}
return super.preHandle(request, response, handler);
}
}
|
package com.MQ.www;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;
public class UsingDropDown {
public static void main(String[] args) {
WebDriver driver=new ChromeDriver();
driver.manage().window().maximize();
driver.get("http://amazon.com");
WebElement l=driver.findElement(By.id("nav-hamburger-menu"));
Select s=new Select(l);
s.selectByIndex(1);
}
}
|
//#if FABRIC>=1
package de.johni0702.minecraft.gui.versions.mixin;
import de.johni0702.minecraft.gui.versions.callbacks.MouseCallback;
import net.minecraft.client.Mouse;
import net.minecraft.client.gui.screen.Screen;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Accessor;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
//#if MC>=11700
//#else
import net.minecraft.client.gui.Element;
//#endif
@Mixin(Mouse.class)
public abstract class MixinMouseListener {
@Accessor // Note: for some reason Mixin doesn't include this in the refmap json if it's just a @Shadow field
abstract int getActiveButton();
@Inject(method = "method_1611", at = @At("HEAD"), cancellable = true)
//#if MC>=11700
//$$ private static void mouseDown(boolean[] result, Screen screen, double x, double y, int button, CallbackInfo ci) {
//#else
private void mouseDown(boolean[] result, double x, double y, int button, CallbackInfo ci) {
//#endif
if (MouseCallback.EVENT.invoker().mouseDown(x, y, button)) {
result[0] = true;
ci.cancel();
}
}
@Inject(method = "method_1605", at = @At("HEAD"), cancellable = true)
//#if MC>=11700
//$$ private static void mouseUp(boolean[] result, Screen screen, double x, double y, int button, CallbackInfo ci) {
//#else
private void mouseUp(boolean[] result, double x, double y, int button, CallbackInfo ci) {
//#endif
if (MouseCallback.EVENT.invoker().mouseUp(x, y, button)) {
result[0] = true;
ci.cancel();
}
}
@Inject(method = "method_1602", at = @At("HEAD"), cancellable = true)
//#if MC>=11700
//$$ private void mouseDrag(Screen screen, double x, double y, double dx, double dy, CallbackInfo ci) {
//#else
private void mouseDrag(Element element, double x, double y, double dx, double dy, CallbackInfo ci) {
//#endif
if (MouseCallback.EVENT.invoker().mouseDrag(x, y, getActiveButton(), dx, dy)) {
ci.cancel();
}
}
@Redirect(
method = "onMouseScroll",
at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screen/Screen;mouseScrolled(DDD)Z")
)
private boolean mouseScroll(Screen element, double x, double y, double scroll) {
if (MouseCallback.EVENT.invoker().mouseScroll(x, y, scroll)) {
return true;
} else {
return element.mouseScrolled(x, y, scroll);
}
}
}
//#endif
|
package evm.dmc.core.api.exceptions;
public class DataOperationException extends RuntimeException {
public DataOperationException(Throwable cause) {
super(cause);
}
public DataOperationException(String message) {
super(message);
}
}
|
package com.decrypt.beeglejobsearch.mvp.presenters;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.v4.content.ContextCompat;
import com.fernandocejas.frodo.annotation.RxLogSubscriber;
import com.decrypt.beeglejobsearch.mvp.models.RootModel;
import com.decrypt.beeglejobsearch.ui.activities.RootActivity;
import javax.inject.Inject;
import com.decrypt.beeglejobsearch.data.storage.ActivityResultDto;
import com.decrypt.beeglejobsearch.data.storage.UserInfoDto;
import com.decrypt.beeglejobsearch.di.DaggerService;
import com.decrypt.beeglejobsearch.di.scopes.RootScope;
import com.decrypt.beeglejobsearch.mvp.models.AccountModel;
import com.decrypt.beeglejobsearch.mvp.views.IRootView;
import com.decrypt.beeglejobsearch.utils.MvpAuthApplication;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;
import rx.subjects.PublishSubject;
public class RootPresenter extends AbstractPresenter<IRootView> {
/**
* Зависимости на AccountModel и RootModel - должны быть именно в корневом Presenter'e так как они
* в дальнейшем много где еще понадобятся.
*/
@Inject
RootModel mRootModel;
@Inject
AccountModel mAccountModel;
public RootPresenter() {
MvpAuthApplication.getRootActivityRootComponent().inject(this);
}
/**
* Горячий обсервабл, который будет излучать данные - даже если на него нет подписчиков
* Через единую шину подписчиков будем оповещать всех своих подписчиков, о том что в onActivityResult -
* вернулись какие-то данные.
*/
private PublishSubject<ActivityResultDto> mActivityResultDtoObs = PublishSubject.create();
public PublishSubject<ActivityResultDto> getActivityResultDtoObs() {
return mActivityResultDtoObs;
}
@Override
public void initView() {
mAccountModel.getUserInfoObs()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new UserInfoSubscriber());
}
public int getCartProductCount() {
return mRootModel.loadCartProductCounter();
}
public void setCartProductCount(int cartProductCount) {
mRootModel.saveCartProductCounter(cartProductCount);
}
/**
* Subscriber необходимо выносить в отедльный класс - т.к. это нужно для корректоного логгирования через Frodo
* @RxLogSubscriber - аннотация от Frodo, для того чтобы мы могли смотреть что приходит в подписчик
*/
@RxLogSubscriber
private class UserInfoSubscriber extends Subscriber<UserInfoDto> {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
if (getView() != null) {
getView().showError(e);
}
}
@Override
public void onNext(UserInfoDto userInfoDto) {
if (getView() != null) {
getView().initDrawer(userInfoDto);
}
}
}
@Override
public void dropComponent() {
DaggerService.unregisterScope(RootScope.class);
super.dropView();
}
public boolean checkPermissionsAndRequestIfNotGranted(@NonNull String[] permissions, int requestCode) {
boolean allGranted = true;
for (String permission : permissions) {
int selfPermission = ContextCompat.checkSelfPermission(((RootActivity) getView()), permission);
if (selfPermission != PackageManager.PERMISSION_GRANTED) {
allGranted = false;
break;
}
}
if (!allGranted) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
((RootActivity) getView()).requestPermissions(permissions, requestCode);
}
return false;
}
return allGranted;
}
/**
* Как только в RootActivity вернется какой-то результат с какой-то другой активности, будет вызван
* метод onActivityResult, который все данные, которые шли, обернет в new ActivtiyResultDto() и эти данные
* он положит нам в подписку, т.е. заимитит туда новые данные.
* Как только новый объект появится в нашем сабжекте, все те кто подписаны на этот сабжект, все подписчики
* будут об этом оповещены и смогут обработать это значение.
* @param requestCode
* @param resultCode
* @param intent
*/
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
mActivityResultDtoObs.onNext(new ActivityResultDto(requestCode, resultCode, intent));
}
public void onRequestPermissionResult(int requestCode, @NonNull String[] permissions,
@NonNull int[] grantResults) {
// TODO: 05.12.2016 implement me
}
}
|
package dao;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "PRODUIT")
public class Produit implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "ID_PRODUIT")
private Long idProduit;
@Column(name = "NOM_PRODUIT", length = 50)
private String nomProduit;
@Column(name = "DATE_EXPIRATION")
private Date dateExpiration;
public Long getIdProduit() {
return idProduit;
}
public void setIdProduit(Long idProduit) {
this.idProduit = idProduit;
}
public String getNomProduit() {
return nomProduit;
}
public void setNomProduit(String nomProduit) {
this.nomProduit = nomProduit;
}
public Date getDateExpiration() {
return dateExpiration;
}
public void setDateExpiration(Date dateExpiration) {
this.dateExpiration = dateExpiration;
}
public Produit(String nomProduit, Date dateExpiration) {
super();
this.nomProduit = nomProduit;
this.dateExpiration = dateExpiration;
}
public Produit() {
super();
}
}
|
import static org.junit.Assert.*;
import org.junit.Test;
public class RomanNumeralUnitTests {
private RomanNumerals number = new RomanNumerals();
@Test
public void testThat3999ReturnsMMMCMXCIX_passed() {
assertEquals("I", number.toRoman(1));
assertEquals("II", number.toRoman(2));
assertEquals("V", number.toRoman(5));
assertEquals("VIII", number.toRoman(8));
assertEquals("XII", number.toRoman(12));
assertEquals("XXIV", number.toRoman(24));
assertEquals("XLIX", number.toRoman(49));
assertEquals("LXXVII", number.toRoman(77));
assertEquals("XCIX", number.toRoman(99));
assertEquals("CCLIV", number.toRoman(254));
assertEquals("DCCLXVIII", number.toRoman(768));
assertEquals("MI", number.toRoman(1001));
assertEquals("MDLXVII", number.toRoman(1567));
assertEquals("MMCCCXXXIII", number.toRoman(2333));
assertEquals("MMMCMXCIX", number.toRoman(3999));
}
}
|
/* 1: */ package com.kaldin.test.settest.action;
/* 2: */
/* 3: */ import com.kaldin.test.settest.dao.impl.QuestionPaperImplementor;
/* 4: */ import com.kaldin.test.settest.dto.QuestionPaperDTO;
/* 5: */ import com.kaldin.test.settest.dto.TopicQuestionDTO;
/* 6: */ import com.kaldin.test.settest.dto.TopicQuestionList;
/* 7: */ import com.kaldin.test.settest.form.QuestionPaperForm;
/* 8: */ import java.io.File;
/* 9: */ import java.io.FileOutputStream;
/* 10: */ import java.util.ArrayList;
/* 11: */ import java.util.Iterator;
/* 12: */ import java.util.List;
/* 13: */ import javax.servlet.ServletContext;
/* 14: */ import javax.servlet.http.HttpServletRequest;
/* 15: */ import javax.servlet.http.HttpServletResponse;
/* 16: */ import javax.servlet.http.HttpSession;
/* 17: */ import org.apache.commons.io.FilenameUtils;
/* 18: */ import org.apache.commons.lang.StringUtils;
/* 19: */ import org.apache.struts.action.Action;
/* 20: */ import org.apache.struts.action.ActionForm;
/* 21: */ import org.apache.struts.action.ActionForward;
/* 22: */ import org.apache.struts.action.ActionMapping;
/* 23: */ import org.apache.struts.action.ActionServlet;
/* 24: */ import org.apache.struts.upload.FormFile;
/* 25: */
/* 26: */ public class QuestionPaperAction
/* 27: */ extends Action
/* 28: */ {
/* 29: */ public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
/* 30: */ throws Exception
/* 31: */ {
/* 32: 43 */ QuestionPaperForm qusForm = (QuestionPaperForm)form;
/* 33: */
/* 34: 45 */ QuestionPaperAction$OPTIONS option = QuestionPaperAction$OPTIONS.get(qusForm.getOpr());
/* 35: */
/* 36: 47 */ String result = "error";
/* 37: */
/* 38: 49 */ int companyid = ((Integer)request.getSession().getAttribute("CompanyId")).intValue();
/* 39: */
/* 40: 51 */ List<TopicQuestionDTO> topicList = new ArrayList();
/* 41: 52 */ topicList = TopicQuestionList.topicquestionlist;
/* 42: */
/* 43: 54 */ QuestionPaperDTO dtoObj = new QuestionPaperDTO();
/* 44: 55 */ QuestionPaperImplementor qpimpl = new QuestionPaperImplementor();
/* 45: */
/* 46: 57 */ FormFile file = qusForm.getExamInfoFile();
/* 47: 58 */ if (file.getFileSize() != 0)
/* 48: */ {
/* 49: 60 */ String filePath = getServlet().getServletContext().getRealPath("/") + "uploads/examinfo";
/* 50: 61 */ String ext = FilenameUtils.getExtension(file.getFileName());
/* 51: 62 */ String fileName = System.currentTimeMillis() + "." + ext;
/* 52: */
/* 53: 64 */ File newFile = new File(filePath, fileName);
/* 54: 66 */ if (!newFile.exists())
/* 55: */ {
/* 56: 67 */ FileOutputStream fos = new FileOutputStream(newFile);
/* 57: 68 */ fos.write(file.getFileData());
/* 58: 69 */ fos.flush();
/* 59: 70 */ fos.close();
/* 60: */ }
/* 61: 72 */ dtoObj.setExamInfoFile(newFile.getName());
/* 62: */ }
/* 63: 75 */ dtoObj.setTestName(qusForm.getTestname());
/* 64: 76 */ dtoObj.setDuration(qusForm.getDuration());
/* 65: 77 */ dtoObj.setNoOfQuestions(qusForm.getNoofquestions());
/* 66: 78 */ dtoObj.setPassingMarks(qusForm.getPassingmarks());
/* 67: 79 */ dtoObj.setTotalMarks(qusForm.getTotalmarks());
/* 68: 80 */ dtoObj.setNegativeMarks(qusForm.getNegativemarks());
/* 69: 81 */ dtoObj.setPerQuestionMarks(qusForm.getPerquestionmarks());
/* 70: 82 */ dtoObj.setLevelid(qusForm.getLevelid());
/* 71: 83 */ dtoObj.setCompanyId(companyid);
/* 72: 84 */ dtoObj.setComments(qusForm.getComments());
/* 73: 85 */ dtoObj.setExmURL(qusForm.getExmURL());
/* 74: 86 */ dtoObj.setVideoURL(StringUtils.trim(qusForm.getVideoURL()));
/* 75: 87 */ dtoObj.setSelectedQuestions(StringUtils.trim(qusForm.getSelectedQuestions()));
/* 76: 88 */ dtoObj.setTestType(qusForm.getTestType());
/* 77: 89 */ if (option == QuestionPaperAction$OPTIONS.ADD)
/* 78: */ {
/* 79: 90 */ String newTestId = qpimpl.getNewTestId();
/* 80: 91 */ dtoObj.setTestId(newTestId);
/* 81: 93 */ if (qpimpl.saveData(dtoObj)) {
/* 82: 94 */ result = "show";
/* 83: */ }
/* 84: 97 */ Iterator<TopicQuestionDTO> itr = topicList.iterator();
/* 85: 98 */ while (itr.hasNext())
/* 86: */ {
/* 87: 99 */ TopicQuestionDTO tpcqDTO = (TopicQuestionDTO)itr.next();
/* 88:100 */ tpcqDTO.setTestId(newTestId);
/* 89:101 */ qpimpl.saveSelectedTopic(tpcqDTO);
/* 90: */ }
/* 91: */ }
/* 92:104 */ if (option == QuestionPaperAction$OPTIONS.EDIT)
/* 93: */ {
/* 94:105 */ dtoObj.setTestId(qusForm.getEdittestid());
/* 95:106 */ dtoObj.setCompanyId(companyid);
/* 96:107 */ if (qpimpl.updateData(dtoObj)) {
/* 97:108 */ result = "show";
/* 98: */ }
/* 99:111 */ qpimpl.deleteExistingTopic(qusForm.getEdittestid());
/* 100:112 */ Iterator<TopicQuestionDTO> itr = topicList.iterator();
/* 101:113 */ while (itr.hasNext())
/* 102: */ {
/* 103:114 */ TopicQuestionDTO tpcqDTO = (TopicQuestionDTO)itr.next();
/* 104:115 */ tpcqDTO.setTestId(qusForm.getEdittestid());
/* 105:116 */ qpimpl.saveSelectedTopic(tpcqDTO);
/* 106: */ }
/* 107: */ }
/* 108:119 */ response.sendRedirect("callCreateQuestionPaper.do?opr=save");
/* 109:120 */ return null;
/* 110: */ }
/* 111: */ }
/* Location: C:\Java Work\Workspace\Kaldin\WebContent\WEB-INF\classes\com\kaldin\kaldin_java.zip
* Qualified Name: kaldin.test.settest.action.QuestionPaperAction
* JD-Core Version: 0.7.0.1
*/ |
package com.keblal.cxfdemo.services;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.keblal.cxfdemo.models.Country;
import com.keblal.cxfdemo.models.CountryElement;
import com.keblal.cxfdemo.models.Place;
import com.keblal.cxfdemo.models.State;
import com.keblal.cxfdemo.models.StateElement;
@Service
public class PlaceServiceImpl implements PlaceService {
static Logger log = Logger.getLogger("PlaceServiceImpl");
@Override
public Place filterPlaceByCountry(String countryName) throws JsonParseException, JsonMappingException, UnsupportedOperationException, IOException {
String countryRestApi = "https://raw.githubusercontent.com/jashyaman/cxfdemo/master/countries.json";
HttpEntity countryEntity = getApiResponse(countryRestApi);
Country country = new ObjectMapper().readValue(countryEntity.getContent(), Country.class);
EntityUtils.consume(countryEntity);
/* fetch required state JSON Data */
String restApi = "https://raw.githubusercontent.com/jashyaman/cxfdemo/master/states.json";
State state = null;
HttpEntity entity = getApiResponse(restApi);
state = new ObjectMapper().readValue(entity.getContent(), State.class);
EntityUtils.consume(entity);
String countryIdTemp = null;
for(CountryElement element : country.getCountries()) {
if(element.getName().equals(countryName)) {
countryIdTemp = element.getId();
log.info("-----------------------------------------------------------country id : " + element.getName());
break;
}
}
log.info("-----------------------------------------------------------country id : " + countryIdTemp);
final String countryId = countryIdTemp;
List<String> stateList = new ArrayList<>();
for(StateElement stateElement : state.getStates()) {
log.info("place : " + stateElement.getName() + " country id " + getCountryName(country,countryId) + " ");
if(stateElement.getCountryId().equals(countryId)) {
System.out.print("found place : " + stateElement.getName() + " country id " +
//country.getCountries().stream()
//.filter(countryElement -> countryElement.getId().equals(countryId))
//.collect(Collectors.toList())
getCountryName(country,countryId)
+ " ");
stateList.add(stateElement.getName());
}
}
if(stateList.isEmpty()) {
stateList.add("no data");
}
return new Place(getCountryName(country,countryId), stateList);
}
private String getCountryName(Country country, String countryId) {
if (countryId == null) {
return "country not recognized";
}
for(CountryElement ce : country.getCountries()) {
if(ce.getId().equals(countryId)) {
log.info("country returned is : " + ce.getName());
return ce.getName();
}
}
return "no country found for id " + countryId + " ";
}
private HttpEntity getApiResponse(String restApi) throws ClientProtocolException, IOException {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(restApi);
CloseableHttpResponse response1 = null;
response1 = httpclient.execute(httpGet);
log.info(response1.getStatusLine()+"");
HttpEntity entity = response1.getEntity();
return entity;
}
}
|
package com.albabich.grad.web.menuitem;
import com.albabich.grad.model.MenuItem;
import com.albabich.grad.repository.MenuItemRepository;
import com.albabich.grad.repository.RestaurantRepository;
import com.albabich.grad.to.MenuItemTo;
import com.albabich.grad.util.MenuItemUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import javax.validation.Valid;
import java.net.URI;
import static com.albabich.grad.util.ValidationUtil.*;
@RestController
@RequestMapping(value = AdminMenuItemController.REST_URL, produces = MediaType.APPLICATION_JSON_VALUE)
public class AdminMenuItemController {
protected static final String EXCEPTION_DUPLICATE_MENU_ITEM_MESSAGE = "You already have menuItem with this name for today";
static final String REST_URL = "/rest/admin/restaurants";
private static final Logger log = LoggerFactory.getLogger(AdminMenuItemController.class);
private final MenuItemRepository menuItemRepository;
private final RestaurantRepository restaurantRepository;
public AdminMenuItemController(MenuItemRepository menuItemRepository, RestaurantRepository restaurantRepository) {
this.menuItemRepository = menuItemRepository;
this.restaurantRepository = restaurantRepository;
}
@GetMapping("/{restaurantId}/menu-items/{id}")
public MenuItem get(@PathVariable int id, @PathVariable int restaurantId) {
log.info("get menuItemTo {} for restaurant {}", id, restaurantId);
MenuItem menuItem = menuItemRepository.findById(id)
.filter(mItem -> mItem.getRestaurant().getId() == restaurantId)
.orElse(null);
return checkNotFoundWithId(menuItem, id, restaurantId);
}
@Transactional
@PostMapping(value = "/{restaurantId}/menu-items", consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<MenuItem> createWithLocation(@Valid @RequestBody MenuItemTo menuItemTo, @PathVariable int restaurantId) {
log.info("create menuItem{} for restaurant {}", menuItemTo, restaurantId);
Assert.notNull(menuItemTo, "menuItemTo must not be null");
checkNew(menuItemTo);
MenuItem menuItem = MenuItemUtil.createNewFromTo(menuItemTo);
menuItem.setRestaurant(restaurantRepository.getOne(restaurantId));
MenuItem created = menuItemRepository.save(menuItem);
URI uriOfNewResource = ServletUriComponentsBuilder.fromCurrentContextPath()
.path(REST_URL + "/" + restaurantId + "/menu-items" + "/{id}")
.buildAndExpand(created.getId()).toUri();
return ResponseEntity.created(uriOfNewResource).body(created);
}
@Transactional
@PutMapping(value = "/{restaurantId}/menu-items/{id}", consumes = MediaType.APPLICATION_JSON_VALUE)
@ResponseStatus(HttpStatus.NO_CONTENT)
public void update(@Valid @RequestBody MenuItemTo menuItemTo, @PathVariable int id, @PathVariable int restaurantId) {
log.info("update menuItemTo {} for restaurant {}", menuItemTo, restaurantId);
try {
Assert.notNull(menuItemTo, "menuItemTo must not be null");
assureIdConsistent(menuItemTo, id);
MenuItem menuItem = get(menuItemTo.id(), restaurantId);
MenuItemUtil.updateFromTo(menuItem, menuItemTo);
menuItemRepository.save(menuItem);
} catch (DataIntegrityViolationException e) {
throw new DataIntegrityViolationException(EXCEPTION_DUPLICATE_MENU_ITEM_MESSAGE);
}
}
@DeleteMapping("/{restaurantId}/menu-items/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable int id, @PathVariable int restaurantId) {
log.info("delete menuItemTo {} for restaurant {}", id, restaurantId);
checkNotFoundWithId(menuItemRepository.delete(id, restaurantId) != 0, id, restaurantId);
}
}
|
package finalProject;
import java.awt.Font;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowAdapter;
import java.io.File;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Dragon extends JLabel implements KeyListener,Runnable {
public int imageState;
public int speed_y=0;
public int speed_x=0;
public int currentHeight=640;
public int reachableHeight=460;
public int leftPos,RightPos;
public boolean toMove;
public int DIR;
public boolean death=false;
public void dragonMove() {
if(this.toMove) {
this.setLocation(this.getX()+this.speed_x,this.getY());
}
}
public Dragon() {
dragon_up();
}
public void dragon_up() {
ImageIcon icon=new ImageIcon("image/dragon_up.png");
this.imageState=0;
this.setIcon(icon);
this.setSize(icon.getIconWidth(),icon.getIconHeight());
}
public void dragon_left() {
this.imageState=1;
ImageIcon icon=new ImageIcon("image/dragon_left.png");
this.setIcon(icon);
this.setSize(icon.getIconWidth(),icon.getIconHeight());
}
public void dragon_right() {
this.imageState=2;
ImageIcon icon=new ImageIcon("image/dragon_right.png");
this.setIcon(icon);
this.setSize(icon.getIconWidth(),icon.getIconHeight());
}
public void dragon_fly() {
this.imageState=3;
ImageIcon icon=new ImageIcon("image/fly.png");
this.setIcon(icon);
this.setSize(icon.getIconWidth(),icon.getIconHeight());
}
public void dragon_death() {
this.imageState=4;
ImageIcon icon=new ImageIcon("image/death.png");
this.setIcon(icon);
this.setSize(icon.getIconWidth(),icon.getIconHeight());
}
public int bottomPosition() {
return this.getY()+47;
}
public int leftX() {
return this.getX();
}
public int rightX() {
return this.getX()+62;
}
public void deathAnime() {
int range=0;
while(true) {
if(range>300) {
break;
}
else {
this.setLocation(this.getX(),this.getY()-1);
range++;
}
try {
Thread.sleep(2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
while(true) {
if(this.getY()>700) {
break;
}
else {
this.setLocation(this.getX(),this.getY()+2);
}
try {
Thread.sleep(3);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
}
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println("ok");
if(e.getKeyCode()==KeyEvent.VK_LEFT&&Gaming.pauseOrNot==false&&this.death==false) {
//System.out.println("in");
toMove=true;
this.speed_x=-2;
this.DIR=LEFT;
if(JumpStair.jumping==false&&FlyStair.flying==false) {
this.dragon_left();
}
}
if(e.getKeyCode()==KeyEvent.VK_RIGHT&&Gaming.pauseOrNot==false&&this.death==false) {
toMove=true;
this.speed_x=2;
this.DIR=RIGHT;
if(JumpStair.jumping==false&&FlyStair.flying==false) {
this.dragon_right();
}
}
}
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
if((e.getKeyCode()==KeyEvent.VK_RIGHT&&DIR!=LEFT )|| (e.getKeyCode()==KeyEvent.VK_LEFT&&DIR!=RIGHT))
toMove=false;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true) {
this.dragonMove();
//this.dragonJump();
try {
Thread.sleep(15);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
|
package com.finix.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.log4j.Logger;
import com.finix.bean.DistrictAdministratorBean;
import com.finix.bean.TalukAdministratorBean;
import com.finix.dao.ITalukAdministratorDao;
import com.finix.dao.utils.ConnectionManager;
public class TalukAdministratorDaoImpl implements ITalukAdministratorDao {
private static ConnectionManager connectionManager = ConnectionManager.getConnectionManager();
final Logger debugLog = Logger.getLogger("debugLogger");
private void catchMethodLogger(String str, Exception e)
{
long startTime1;
startTime1 = System.currentTimeMillis();
Date date = new Date(startTime1);
DateFormat formatter = new SimpleDateFormat("HH:mm:ss:SSS");
String dateFormatted = formatter.format(date);
debugLog.error("***************" );
debugLog.error("Government Dao Impl :Method Name "+str );
debugLog.error("Exception Occured Time " +dateFormatted);
debugLog.error("Type of Exception"+e);
debugLog.error("***************" );
}
TalukAdministratorBean talukAdministratorBean = new TalukAdministratorBean();
//getTalukAdminDetails
public TalukAdministratorBean getTalukAdminDetails(TalukAdministratorBean talukAdministratorBean) throws Exception {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try
{
conn = connectionManager.getConnection();
String sql = "SELECT taluk_administrator_name,taluk_administrator_email,taluk_administrator_mobile,taluk_id,district_id,government_report_type_id FROM taluk_administrator_detail WHERE taluk_administrator_id=?";
ps = conn.prepareStatement(sql);
ps.setInt(1, talukAdministratorBean.getTaluk_administrator_id());
rs = ps.executeQuery();
while(rs.next())
{
talukAdministratorBean.setTaluk_administrator_name(rs.getString("taluk_administrator_name"));
talukAdministratorBean.setTaluk_administrator_email(rs.getString("taluk_administrator_email"));
talukAdministratorBean.setTaluk_administrator_mobile(rs.getString("taluk_administrator_mobile"));
talukAdministratorBean.setTaluk_id(rs.getInt("taluk_id"));
talukAdministratorBean.setDistrict_id(rs.getInt("district_id"));
talukAdministratorBean.setGovernment_report_type_id(rs.getInt("government_report_type_id"));
}
}
catch (Exception e)
{
e.printStackTrace();
String str = "getDistrictAdminDetails";
catchMethodLogger(str, e);
}
finally
{
if(conn!=null)
{
connectionManager.releaseConnection(conn);
}
}
return talukAdministratorBean;
}
//checkTalukOldPasswordAvailable
public String checkTalukOldPasswordAvailable(String oldPassword, TalukAdministratorBean talukAdministratorBean) throws Exception {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
String status = null;
try
{
conn = connectionManager.getConnection();
String sql="SELECT email FROM login WHERE taluk_administrator_id=? AND PASSWORD=?";
ps=conn.prepareStatement(sql);
ps.setInt(1, talukAdministratorBean.getTaluk_administrator_id());
ps.setString(2,oldPassword);
rs=ps.executeQuery();
if(rs.next())
{
status = "match";
}
else
{
status = "misMatch";
}
}
catch(Exception e)
{
e.printStackTrace();
String str = "District Admin Dao Impl :checkTalukOldPasswordAvailable";
catchMethodLogger(str, e);
}
finally
{
if(conn!=null)
{
connectionManager.releaseConnection(conn);
}
}
return status;
}
//updateTalukPasswordDetails
public TalukAdministratorBean updateTalukPasswordDetails(TalukAdministratorBean talukAdministratorBean)throws Exception {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try
{
conn=connectionManager.getConnection();
String select="SELECT PASSWORD FROM login WHERE taluk_administrator_id=? AND PASSWORD=?";
ps=conn.prepareStatement(select);
ps.setInt(1,talukAdministratorBean.getTaluk_administrator_id());
ps.setString(2, talukAdministratorBean.getOld_password());
rs=ps.executeQuery();
if(rs.next())
{
String update="update login set password=? where taluk_administrator_id=?";
ps=conn.prepareStatement(update);
ps.setString(1, talukAdministratorBean.getPassword());
ps.setInt(2, talukAdministratorBean.getTaluk_administrator_id());
int s=ps.executeUpdate();
if(s==1)
{
talukAdministratorBean.setStatus("success");
}
}
else
{
talukAdministratorBean.setStatus("error");
}
}
catch(Exception e)
{
e.printStackTrace();
String str = "updatePasswordDetails";
catchMethodLogger(str, e);
}
finally
{
if(conn!=null)
{
connectionManager.releaseConnection(conn);
}
}
return talukAdministratorBean;
}
}
|
package ch.fhnw.edu.cpib.scanner.enumerations;
import ch.fhnw.edu.cpib.scanner.interfaces.IToken;
public enum Changemodes implements IToken {
VAR, CONST
}
|
package com.vilio.pcfs.dao;
import com.vilio.pcfs.pojo.User;
public interface UserDao {
//查询用户
public User queryUser(User User);
//更改用户登录失败次数
public int updateLoginErrorByUserName(User User);
//更改用户锁定状态
public int updateHashLockByPrimaryKey(User User);
}
|
package com.yosep.msa.account;
import java.time.LocalDateTime;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class YoggaebiUser {
// @Id
// @GeneratedValue(strategy=GenerationType.IDENTITY)
// private Long id;
@Id
@Column(length = 30)
private String userName;
@Column(length = 100, nullable = false)
private String password;
@Column(length=50, nullable=false)
private String name;
@Column(length=100, nullable=false)
private String email;
@Column(length=50, nullable=false)
private String phone;
@Column(length=50, nullable=false)
private String postCode;
@Column(length=50, nullable=false)
private String roadAddr;
@Column(length=50, nullable=false)
private String jibunAddr;
@Column(length=50, nullable=false)
private String extraAddr;
@Column(length=50, nullable=false)
private String detailAddr;
@Column
private LocalDateTime userRdate;
@Column
private LocalDateTime userUdate;
@ElementCollection(fetch=FetchType.EAGER)
@Enumerated(value=EnumType.STRING)
private Set<YoggaebiUserRole> roles;
}
|
package main.java;
import org.codehaus.janino.Java;
import java.sql.*;
public class loc_mysql_test {
public static void main(String[] args){
try {
Class.forName("com.mysql.jdbc.Driver");
System.out.println("成功加载MySQL驱动！");
} catch (ClassNotFoundException e) {
System.out.println("找不到MySQL驱动!");
e.printStackTrace();
}
Connection conn;
PreparedStatement pstm =null;
try {
//String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/spark?useUnicode=true&characterEncoding=utf8";
conn = DriverManager.getConnection(url,"root","111111");
//创建一个Statement对象
System.out.print("成功连接到数据库！");
String sql = "INSERT INTO record(title,author,dt) VALUES(?,?,?)";
pstm = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
pstm.setString(1,"mysql_writing_test");
// pstm.setInt(1,4);
pstm.setString(2,"Unknow");
pstm.setDate(3,new Date(new java.util.Date().getTime()));
// pstm.addBatch(); //批量处理
// pstm.executeBatch()
//setAutoCommit（false）禁止事物自动提交，通过提交Commit()或是回退rollback()来管理事务的操作
pstm.executeUpdate();
ResultSet rs = pstm.getGeneratedKeys();
rs.next();
int key = rs.getInt(1);
System.out.println(key);
conn.close();
} catch (SQLException e){
e.printStackTrace();
}
}
}
|
package Shape;
public class Cube extends ThreedimensionalShape{
public Cube(int teref) {
super(teref);
// TODO Auto-generated constructor stub
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return 6*Math.pow(getTeref(), 2);
}
@Override
public double getVolume() {
// TODO Auto-generated method stub
return Math.pow(getTeref(), 3);
}
}
|
package imed;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class AcessoBanco {
public static void main(String[] args) {
Connection con;
try {
String url = "jdbc:sqlite:C:\\TEMP\\imed.db";
con = DriverManager.getConnection(url);
System.out.println("Ok!");
String sql = "SELECT id_produto, nome, preco FROM produto";
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
List<Produto> produtos = new ArrayList<>();
while (rs.next()) {
Produto p = new Produto();
p.setId(rs.getInt("id_produto"));
p.setNome(rs.getString("nome"));
p.setPreco(rs.getDouble("preco"));
produtos.add(p);
}
//System.out.println(produtos.get(0).getNome());
sql = "SELECT id_pedido, vl_total FROM pedido";
stmt = con.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
Pedido p = new Pedido();
p.setId(rs.getInt("id_pedido"));
p.setValorTotal(rs.getDouble("vl_total"));
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
|
/*
* 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 it.unive.dagg.card;
import it.unive.interfaces.Flash;
import it.unive.interfaces.Player;
/**
*Crea una carta istantanea
* @author alessandro
*/
public class InstantCard extends AbstractCard implements Flash{
/**
* Costruttore della carta istantanea
* @param name
* @param desc
*/
public InstantCard(String name, String desc) {
super(name, desc);
}
/**
* Assegna un caster
* @param caster
*/
@Override
public void flash(Player caster) {
this.cast(caster);
}
}
|
package udacity.project.lynsychin.popularmovies;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.LiveData;
import android.os.Bundle;
import android.widget.TextView;
import java.util.List;
import udacity.project.lynsychin.popularmovies.database.MovieDatabase;
import udacity.project.lynsychin.popularmovies.database.MovieEntry;
public class DemoActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_demo);
TextView demoText = findViewById(R.id.demoText);
MovieDatabase mDB = MovieDatabase.getInstance(this);
}
}
|
package com.nlpeng.config.task;
/**
* @author Ferry NLP
* @create 2019-09-05
* @see
* @since 1.0v
**/
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
@Configuration
@EnableScheduling//定时任务
public class TaskSchedulerConfig implements SchedulingConfigurer {
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskScheduler());
}
@Bean(destroyMethod="shutdown")
public Executor taskScheduler(){
//return Executors.newFixedThreadPool(100);//创建一个线程池 固定线程数
return Executors.newScheduledThreadPool(100);//创建一个线程池 核心线程 数定期执行任务，支持固定频率和固定延迟
}
} |
package in.tanjo.sushi.listener;
import android.view.View;
import static android.support.v7.widget.RecyclerView.Adapter;
public interface OnRecyclerViewAdapterItemClickListener<T> {
void onItemClick(View v, Adapter adapter, int position, T model);
void onItemLongClick(View v, Adapter adapter, int position, T model);
}
|
package com.rofour.baseball.controller.order;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import com.rofour.baseball.common.DateUtils;
import com.rofour.baseball.controller.base.BaseController;
import com.rofour.baseball.service.order.OrderAnalysisService;
/**
* 订单运营统计分析
*
* @author wuzhiquan
*
*/
@Controller
@RequestMapping("/order/analysis")
public class OrderAnalysisController extends BaseController {
@Autowired
@Qualifier("orderAnalysisService")
OrderAnalysisService orderAnalysisService;
/**
* 订单运营统计分析页面
*
* @param request
* @return
* @throws Exception
* @author wuzhiquan
*/
@RequestMapping(value = "/index", method = RequestMethod.GET)
public ModelAndView index(HttpServletRequest request) throws Exception {
if (null != request.getSession().getAttribute("user")) {
return new ModelAndView("order/analysis/index");
} else {
return new ModelAndView("error/noPermission");
}
}
/**
* 订单统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrder", method = RequestMethod.POST)
public void getOrder(HttpServletRequest request, HttpServletResponse response) {
// String yesterday = DateUtils.format(DateUtils.getYesterday(), "yyyy-MM-dd");
String yesterday = "2016-10-28";
Map<String, Object> map = orderAnalysisService.getOrder(yesterday);
writeJson(map, response);
}
/**
* 各时段订单统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrderByHours", method = RequestMethod.POST)
public void getOrderByHours(HttpServletRequest request, HttpServletResponse response) {
// String yesterday = DateUtils.format(DateUtils.getYesterday(), "yyyy-MM-dd");
String yesterday = "2016-10-28";
List<Map<String, Object>> list = orderAnalysisService.getOrderByHours(yesterday);
writeJson(list, response);
}
/**
* 前10天订单金额统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrderAmountByTenDay", method = RequestMethod.POST)
public void getOrderAmountByTenDay(HttpServletRequest request, HttpServletResponse response) {
// List<Map<String, Object>> list = orderAnalysisService.getOrderAmountByTenDay(getTenDaysBefore());
List<Map<String, Object>> list = orderAnalysisService.getOrderAmountByTenDay("2016-10-19");
writeJson(list, response);
}
/**
* 前10天订单类型统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrderTypeByTenDay", method = RequestMethod.POST)
public void getOrderTypeByTenDay(HttpServletRequest request, HttpServletResponse response) {
// List<Map<String, Object>> list = orderAnalysisService.getOrderTypeByTenDay(getTenDaysBefore());
List<Map<String, Object>> list = orderAnalysisService.getOrderTypeByTenDay("2016-10-19");
writeJson(list, response);
}
/**
* 各地区订单统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrderByAreas", method = RequestMethod.POST)
public void getOrderByAreas(HttpServletRequest request, HttpServletResponse response) {
// String yesterday = DateUtils.format(DateUtils.getYesterday(), "yyyy-MM-dd");
String yesterday = "2016-10-28";
List<Map<String, Object>> list = orderAnalysisService.getOrderByAreas(yesterday);
writeJson(list, response);
}
/**
* 前10天订单小派统计分析
*
* @param request
* @param response
* @author wuzhiquan
*/
@ResponseBody
@RequestMapping(value = "/getOrderWinnerByTenDay", method = RequestMethod.POST)
public void getOrderWinnerByTenDay(HttpServletRequest request, HttpServletResponse response) {
// List<Map<String, Object>> list = orderAnalysisService.getOrderWinnerByTenDay(getTenDaysBefore());
List<Map<String, Object>> list = orderAnalysisService.getOrderWinnerByTenDay("2016-10-19");
writeJson(list, response);
}
/**
* 获取前10天
*
* @return
* @author wuzhiquan
*/
private String getTenDaysBefore() {
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE, -10);
return DateUtils.format(c.getTime(), "yyyy-MM-dd");
}
}
|
package controlers;
import java.util.ArrayList;
import data.DataPais;
import data.DataUsuario;
import entity.Pais;
import entity.Usuario;
public class CtrlABMUsuario {
private DataUsuario dataUsu;
private DataPais dataPais;
public CtrlABMUsuario(){
dataUsu = new DataUsuario();
dataPais = new DataPais();
}
public void add(Usuario u) throws Exception{
dataUsu.add(u);
}
public void delete(Usuario u)throws Exception{
dataUsu.remove(u);
}
public void update(Usuario u)throws Exception{
dataUsu.update(u);
}
public Usuario getUsuario(Usuario u) throws Exception{
return this.dataUsu.getByUsuario(u);
}
public Usuario getById(Usuario u) throws Exception{
return dataUsu.getById(u);
}
public Usuario getByUsuario(String usuario)throws Exception{
Usuario u=new Usuario();
u.setUsuario(usuario);
return dataUsu.getByUsuario(u);
}
public Usuario getByNombreApellido(Usuario u) throws Exception{
return dataUsu.getByNombreApellido(u);
}
public ArrayList<Usuario> getAll()throws Exception{
return dataUsu.getAll();
}
public String usuarioListText() throws Exception {
String texto="Apellido\tNombre\tPais\n";
ArrayList<Usuario> usuarios =this.getAll();
for (Usuario u : usuarios){
texto= texto +u.getApellido()+"\t"+u.getNombre()+"\t"+
u.getPais().getNombre()+"\n";
}
return texto;
}
public ArrayList<Pais> getPaises() throws Exception{
return dataPais.getAll();
}
public Usuario login(Usuario usu) throws Exception{
return dataUsu.getLogedUser(usu);
}
} |
package com.yinghai.a24divine_user.utils;
import com.example.fansonlib.base.AppUtils;
import com.yinghai.a24divine_user.R;
/**
* @author Created by：fanson
* Created Time: 2017/11/13 11:38
* Describe：星座转换类
*/
public class ConstellationUtils {
/**
* 根据后台对应的code获取字符串
* @param code 后台对应的code
* @return 字符串
*/
public static String getString(int code) {
String result = "";
switch (code) {
case 1:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[0];
break;
case 2:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[1];
break;
case 3:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[2];
break;
case 4:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[3];
break;
case 5:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[4];
break;
case 6:
result =AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[5];
break;
case 7:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[6];
break;
case 8:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[7];
break;
case 9:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[8];
break;
case 10:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[9];
break;
case 11:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[10];
break;
case 12:
result = AppUtils.getAppContext().getResources().getStringArray(R.array.constellation_array)[11];
break;
default:
break;
}
return result;
}
/**
* 根据字符串获取后台对应的code
* @param content 字符串
* @return 后台对应的code
*/
public static int getCode(String content) {
int code = -1;
switch (content) {
case "水瓶座":
code = 1;
break;
case "双鱼座":
code = 2;
break;
case "白羊座":
code = 3;
break;
case "金牛座":
code = 4;
break;
case "双子座":
code = 5;
break;
case "巨蟹座":
code = 6;
break;
case "狮子座":
code = 7;
break;
case "处女座":
code = 8;
break;
case "天秤座":
code = 9;
break;
case "天蝎座":
code = 10;
break;
case "射手座":
code =11;
break;
case "魔蝎座":
code = 12;
break;
default:
break;
}
return code;
}
}
|
package searchcodej.util;
public class RegexMatch {
private int begin;
private int end;
public RegexMatch(int begin, int end) {
super();
if(end <= begin)
throw new IllegalArgumentException(
"the value of begin must be greater than the end.");
this.begin = begin;
this.end = end;
}
public boolean isBefore(RegexMatch otherMatch) {
return (this.end <= otherMatch.begin);
}
public boolean isAfter(RegexMatch otherMatch) {
return (otherMatch.end <= this.begin);
}
/*
* this match1 is inside other match2?
* a2 a1 b1 b2
* | | | |
*/
public boolean isInside(RegexMatch otherMatch) {
boolean a = this.begin >= otherMatch.begin;
boolean b = this.end <= otherMatch.end;
return (a && b);
}
public boolean testConflict(RegexMatch otherMatch) {
boolean result = false;
if (begin < otherMatch.begin && end <= otherMatch.begin) {
//System.out.println("no conflict case 1");
} else if (otherMatch.begin < begin && otherMatch.end <= begin) {
//System.out.println("no conflict case 2");
} else {
//System.out.println("we have a conflict");
result = true;
}
return result;
}
public int getBegin() {
return begin;
}
public int getEnd() {
return end;
}
@Override
public String toString() {
return "[" + begin + "," + end + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + begin;
result = prime * result + end;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
RegexMatch other = (RegexMatch) obj;
if (begin != other.begin)
return false;
if (end != other.end)
return false;
return true;
}
}
|
package com.codecow.dao;
import com.codecow.entity.SysRolePermission;
import java.util.List;
public interface SysRolePermissionMapper {
int deleteByPrimaryKey(String id);
int insert(SysRolePermission record);
int insertSelective(SysRolePermission record);
SysRolePermission selectByPrimaryKey(String id);
int updateByPrimaryKeySelective(SysRolePermission record);
int updateByPrimaryKey(SysRolePermission record);
int batchInsertRolePermission(List<SysRolePermission>list);
List<String>getRoleIdsByPermissionId(String permissionId);
int removeByPermissionId(String permissionId);
/**
* 根据roldId获取与角色相关的菜单id(编辑角色时使用)
* @param roleId 角色id
* @return 返回与该角色相关的菜单id
*/
List<String>getPermissionIdsByRoleId(String roleId);
int removeByRoleId(String roleId);
List<String> getPermissionIdsByRoleIds(List<String> roleIds);
}
|
package db.pojos;
import java.io.Serializable;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.*;
@Entity
@Table(name = "rating")
public class Rating implements Serializable {
/**
*
*/
private static final long serialVersionUID = -3167341965153243574L;
@EmbeddedId
ratingKey id;
private Integer score;
private String review;
@ManyToOne(fetch = FetchType.LAZY)
@MapsId("id_doctor")
@JoinColumn(name = "id_doctor")
private Doctor doc;
@ManyToOne(fetch = FetchType.LAZY)
@MapsId("id_patient")
@JoinColumn(name = "id_patient")
private Patient pat;
public Rating() {
super();
}
public Rating(Doctor doc, Patient pat, Integer score, String review) {
super();
this.score = score;
this.review = review;
this.doc = doc;
this.pat = pat;
}
public Rating(Integer score, String review) {
super();
this.score = score;
this.review = review;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((review == null) ? 0 : review.hashCode());
result = prime * result + ((score == null) ? 0 : score.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Rating other = (Rating) obj;
if (review == null) {
if (other.review != null)
return false;
} else if (!review.equals(other.review))
return false;
if (score == null) {
if (other.score != null)
return false;
} else if (!score.equals(other.score))
return false;
return true;
}
public Integer getScore() {
return score;
}
public void setScore(Integer score) {
this.score = score;
}
public String getReview() {
return review;
}
public void setReview(String review) {
this.review = review;
}
//Rating doesnt print doctor and patient
@Override
public String toString() {
return "Rating [score=" + score + ", review=" + review + "]";
}
public Doctor getDoc() {
return doc;
}
public void setDoc(Doctor doc) {
this.doc = doc;
}
public Patient getPat() {
return pat;
}
public void setPat(Patient pat) {
this.pat = pat;
}
}
@Embeddable
class ratingKey implements Serializable {
@JoinColumn(name = "id_patient")
Integer id_patient;
@JoinColumn(name = "id_doctor")
Integer id_doctor;
public ratingKey() {
super();
}
public ratingKey(Integer id_patient, Integer id_doctor) {
super();
this.id_patient = id_patient;
this.id_doctor = id_doctor;
}
public Integer getId_patient() {
return id_patient;
}
public void setId_patient(Integer id_patient) {
this.id_patient = id_patient;
}
public Integer getId_doctor() {
return id_doctor;
}
public void setId_doctor(Integer id_doctor) {
this.id_doctor = id_doctor;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id_doctor == null) ? 0 : id_doctor.hashCode());
result = prime * result + ((id_patient == null) ? 0 : id_patient.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ratingKey other = (ratingKey) obj;
if (id_doctor == null) {
if (other.id_doctor != null)
return false;
} else if (!id_doctor.equals(other.id_doctor))
return false;
if (id_patient == null) {
if (other.id_patient != null)
return false;
} else if (!id_patient.equals(other.id_patient))
return false;
return true;
}
}
|
package com.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
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.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.model.DetailskillDTO;
import com.model.ListSkillDTO;
import com.model.SkillDTO;
import com.model.UserDTO;
import com.service.DetailSkillService;
import com.service.SkillService;
import com.service.UserService;
@RestController
public class RestSkillController {
@Autowired
UserService userService;
@Autowired
SkillService skillService;
@Autowired
DetailSkillService detailSkillService;
@RequestMapping(value="/addSkill",method = RequestMethod.POST)
@ResponseStatus(code=HttpStatus.CREATED)
public void addSkill(@RequestBody ListSkillDTO listSkill) {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication.getAuthorities().toString().equals("[ROLE_ANONYMOUS]") != true) {
UserDTO user = userService.getUserByUserName(authentication.getName());
int id = user.getUser_ID();
skillService.deleteAllSkillById(id);
if (!listSkill.getListSkill().isEmpty()) {
for (SkillDTO skillDTO : listSkill.getListSkill()) {
skillService.addSkill(skillDTO, id);
int skill_ID = skillService.getIdSkillByUserId(id);
if (!skillDTO.getDetailSkills().isEmpty()) {
for (DetailskillDTO detailskillDTO : skillDTO.getDetailSkills()) {
detailSkillService.addDetailSkill(detailskillDTO, skill_ID);
}
}
}
}
}
}
@RequestMapping(value="/add",method = RequestMethod.POST)
@ResponseStatus(code=HttpStatus.CREATED)
public void add(@RequestBody UserDTO userDTO) {
System.out.println(userDTO.getName());
}
}
|
import java.util.Scanner;
public class pascaltrianglebruten3 {
public static void main(String[] args) {
int number=scan();
pascal(number);
}
public static int scan() {
Scanner scan=new Scanner(System.in);
int n =scan.nextInt();
scan.close();
return n;
}
public static void pascal(int number) {
//n fpor nCr
for(int n=0;n<number;n++){
//r for nCr
for(int r=0;r<=n;r++){
System.out.print( combination(n,r)+" ");
}
//nextline
System.out.println("");
}
}
public static int combination(int n,int r) {
int ans=1;
if(r>n-r){
r=n-r;
}
for (int i = 0; i < r; i++) {
ans*=n-i;
ans/=i+1;
}
return ans;
}
} |
/**
* original(c) zhuoyan company
* projectName: java-design-pattern
* fileName: SimpleCommand.java
* packageName: cn.zy.pattern.command.simple
* date: 2018-12-19 22:31
* history:
* <author> <time> <version> <desc>
* 作者姓名 修改时间 版本号 描述
*/
package cn.zy.pattern.command.simple;
/**
* @version: V1.0
* @author: ending
* @className: SimpleCommand
* @packageName: cn.zy.pattern.command.simple
* @description: 抽线命令类
* @data: 2018-12-19 22:31
**/
public abstract class SimpleCommand {
public abstract void execute();
} |
package com.example.letsgo;
import android.content.DialogInterface;
import android.os.Handler;
import android.os.Message;
import android.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.google.gson.Gson;
import java.io.IOException;
import model.Code;
import model.Register;
import model.responseRegister;
import okhttp3.Call;
import okhttp3.Response;
import util.Picker;
import static util.Check.isEmail;
import static util.Check.isMobileNO;
import static util.httpUtil.sendHttpPost;
import static util.httpUtil.sendHttpRequest;
public class RegisterActivity extends AppCompatActivity {
private Button identify;
private Button register;
private EditText account;
private EditText code;
private EditText password;
private EditText nickname;
private Button gender;
private EditText Tel;
private Gson gson = new Gson();
private Code responseCode;
private responseRegister responseRegister;
private Register myRegister;
private Picker picker=new Picker();
public static final int OK = 1;
public static final int FAILURE = 0;
public static final int TEST = -1;
public static final int GETCODE = 2;
public static final int GETREGISTER = 3;
private String responseData;
private Handler handler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case GETCODE:
responseCode = gson.fromJson(msg.obj.toString(), Code.class);
if (responseCode.getStatus().equals("OK")) {
} else if (responseCode.getStatus().equals("ERROR")) {
identify.setClickable(true);
identify.setText("发送验证码");
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage(responseCode.getMessage())
.setPositiveButton("确定", null)
.show();
}
break;
case GETREGISTER:
if (responseRegister.getStatus().equals("OK")) {
MainActivity.myToken = responseRegister.getToken();
MainActivity.myUserid = myRegister.getUserid();
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册成功")
.setMessage("注册成功，将自动返回登录")
.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
finish();
}
})
.show();
} else {
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage(responseRegister.getMessage())
.setPositiveButton("确定", null)
.show();
}
break;
case TEST:
break;
default:
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_register);
initViews();
identify.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (!isEmail(account.getText().toString())) {
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage("请输入正确的邮箱")
.setPositiveButton("确定", null)
.show();
return;
}
identify.setClickable(false);
identify.setText("已发送");
Register register = new Register();
register.setUserid(account.getText().toString());
register.setType(0);
sendHttpPost("https://shiftlin.top/cgi-bin/Verify.py", gson.toJson(register), new okhttp3.Callback() {
@Override
public void onResponse(Call call, Response response) throws IOException {
Message message = new Message();
message.obj = response.body().string();
message.what = GETCODE;
handler.sendMessage(message);
}
@Override
public void onFailure(Call call, IOException e) {
e.printStackTrace();
}
});
}
});
register.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (!code.getText().toString().equals(responseCode.getCode())) {
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage("验证码输入错误")
.setPositiveButton("确定", null)
.show();
return;
}
if (isMobileNO(Tel.getText().toString())) {
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage("请输入正确的电话号码")
.setPositiveButton("确定", null)
.show();
return;
}
if(password.getText().toString().length()<6){
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage("密码长度太短")
.setPositiveButton("确定", null)
.show();
return;
}
if(nickname.getText().toString().length()>10){
new AlertDialog.Builder(RegisterActivity.this)
.setTitle("注册错误")
.setMessage("昵称长度太长")
.setPositiveButton("确定", null)
.show();
return;
}
myRegister = new Register();
myRegister.setUserid(account.getText().toString());
myRegister.setPassword(password.getText().toString());
myRegister.setNickname(nickname.getText().toString());
myRegister.setTel(Tel.getText().toString());
if (gender.getText().toString().equals("男"))
myRegister.setGender(1);
else if (gender.getText().toString().equals("女"))
myRegister.setGender(2);
else myRegister.setGender(0);
sendHttpPost("https://shiftlin.top/cgi-bin/Register", gson.toJson(myRegister), new okhttp3.Callback() {
@Override
public void onResponse(Call call, Response response) throws IOException {
Log.d("**TEST**", "Success-Register");
responseRegister = gson.fromJson(response.body().string(), responseRegister.class);
Message message = new Message();
message.what = GETREGISTER;
message.obj = responseRegister;
handler.sendMessage(message);
}
@Override
public void onFailure(Call call, IOException e) {
e.printStackTrace();
}
});
}
});
}
private void initViews() {
identify = (Button) findViewById(R.id.identify);
register = (Button) findViewById(R.id.register_r);
account = (EditText) findViewById(R.id.account_r);
password = (EditText) findViewById(R.id.password_r);
code = (EditText) findViewById(R.id.code);
nickname = (EditText) findViewById(R.id.nickname_r);
gender = (Button) findViewById(R.id.gender_r);
Tel = (EditText) findViewById(R.id.Tel_r);
gender.setOnClickListener(GenderListener);
}
protected View.OnClickListener GenderListener = new View.OnClickListener() {
@Override
public void onClick(View view) {
picker.onConstellationPicker(RegisterActivity.this, 4);
}
};
}
|
package org.inftel.pasos.controlador;
import org.inftel.pasos.modelo.Modelo;
public class Controlador implements IControlador{
private Modelo modelo;
public Controlador(Modelo modelo){
this.modelo = modelo;
}
public void setNotifVibrador(Boolean b) {
this.modelo.setNotifVibracion(b);
}
public void setNotifVoz(Boolean b) {
this.modelo.setNotifVoz(b);
}
public void setTema(int t) {
this.modelo.setTema(t);
}
public void setTamTexto(float t) {
modelo.setTamTexto(t);
}
public void aumentarTexto() {
float t = modelo.getTamTexto();
modelo.setTamTexto(t+2);
}
public void disminuirTexto() {
float t = modelo.getTamTexto();
modelo.setTamTexto(t-2);
}
public Boolean getNotifVibracion() {
return this.modelo.getNotifVibracion();
}
public Boolean getNotifVoz() {
return this.modelo.getNotifVoz();
}
public int getTema() {
return this.modelo.getTema();
}
public float getTamTexto() {
return this.modelo.getTamTexto();
}
}
|
package com.gmail.cwramirezg.task.data.pojos;
import com.google.gson.annotations.SerializedName;
public class MensajeResponse {
@SerializedName("exit_code")
private int cod;
@SerializedName("message")
private String msg;
public MensajeResponse(int cod, String msg) {
this.cod = cod;
this.msg = msg;
}
public int getCod() {
return cod;
}
public void setCod(int cod) {
this.cod = cod;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
|
/*
* 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 usingoperators;
/**
*
* @author 20111
*/
public class UsingOperators {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 4;
int y = 8;
System.out.println("x = " + x);
System.out.println("y = " + y);
int sum;
sum = x + y; //compute sum
System.out.println("x + y = " + sum); //print sum
int product;
product = x * y;
System.out.println("x * y = " + product);
double average;
average = sum / 2.0;
System.out.println("x / y = " + average);
double halfX;
double halfY;
halfX = x/2.0;
System.out.println("x / 2.0 = " + halfX);
halfY = y/2.0;
System.out.println("y / 2.0 = " + halfY);
/*
x = 4
y = 8
x + y = 12
x * y = 32
x / y = 6.0
x / 2.0 = 2.0
y / 2.0 = 4.0 */
}
}
|
/*
* 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 tolteco.sigma.model.entidades;
import java.util.Date;
/**
*
* @author JFPS
*/
public class Major implements PrimaryKeyComparable{
int majorVer;
Date majorDate;
String majorName,
majorNotes;
public Major(int majorVer, String majorName, Date majorDate, String majorNotes) {
if (majorVer < 0) throw new IllegalArgumentException("Número de versão negativo: " + majorVer);
else this.majorVer = majorVer;
this.majorDate = majorDate;
this.majorName = majorName;
this.majorNotes = majorNotes;
}
public int getMajorVer() {
return majorVer;
}
public Date getMajorDate() {
return majorDate;
}
public String getMajorNotes() {
return majorNotes;
}
public String getMajorName() {
return majorName;
}
@Override
public int getRowId() {
return majorVer;
}
} |
package com.tencent.mm.plugin.topstory.ui.video;
import android.view.View;
import android.view.View.OnClickListener;
import com.tencent.mm.kernel.g;
import com.tencent.mm.plugin.topstory.a.b;
class n$10 implements OnClickListener {
final /* synthetic */ n oBM;
n$10(n nVar) {
this.oBM = nVar;
}
public final void onClick(View view) {
n.b(this.oBM).bHU().oAl = 2;
if (n.c(this.oBM) == null || n.c(this.oBM).bIE() != n.b(this.oBM).bHP()) {
n.b(this.oBM).ye(n.d(this.oBM));
n.b(this.oBM).bHU().b(n.e(this.oBM));
((b) g.n(b.class)).getReporter().a(n.b(this.oBM).bHT(), n.e(this.oBM), n.d(this.oBM), 2, "");
return;
}
this.oBM.iB(!n.b(this.oBM).bHR().ozV);
}
}
|
package org.stepik.api.objects.submissions;
import org.jetbrains.annotations.NotNull;
/**
* @author meanmail
*/
public enum ReviewStatus {
DONE, AWAITING;
@NotNull
@Override
public String toString() {
return name().toLowerCase();
}
}
|
package com.ab.yuri.aifuwu.RecyclerView;
import android.content.Context;
import android.content.Intent;
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.ab.yuri.aifuwu.R;
import com.ab.yuri.aifuwu.RunActivity;
import com.ab.yuri.aifuwu.SchooldaysActivity;
import com.ab.yuri.aifuwu.ScoreActivity;
import com.bumptech.glide.Glide;
import java.util.List;
/**
* Created by Yuri on 2017/2/3.
*/
public class AboutUsAdapter extends RecyclerView.Adapter<AboutUsAdapter.ViewHolder> {
private Context mContext;
private List<Uses> mUsesList;
static class ViewHolder extends RecyclerView.ViewHolder{
ImageView useImg;
TextView useName;
public ViewHolder(View view) {
super(view);
useImg= (ImageView) view.findViewById(R.id.about_us_item_img);
useName= (TextView) view.findViewById(R.id.about_us_item_txt);
}
}
public AboutUsAdapter(List<Uses> usesList){
mUsesList=usesList;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if (mContext==null){
mContext=parent.getContext();
}
View view= LayoutInflater.from(parent.getContext()).inflate(R.layout.about_us_item,parent,false);
ViewHolder holder=new ViewHolder(view);
return holder;
}
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
Uses uses=mUsesList.get(position);
holder.useName.setText(uses.getName());
Glide.with(mContext).load(uses.getImgId()).into(holder.useImg);
}
@Override
public int getItemCount() {
return mUsesList.size();
}
}
|
package com.bbb.composite.product.details.services.client;
import java.util.List;
import com.bbb.composite.product.details.dto.sku.SkuDTO;
/**
* SkuIntegrationService Interface.
*
* @author psh111
*
*/
@FunctionalInterface
public interface SkuIntegrationService {
/**
* Fetch SKU Details based on channel, siteId and ChildSkus
*
* @param bbbChannel channel value
* @param siteId site Id
* @param childSkus list of ChildSkus
* @return value as List of SkuDto
*/
public List<SkuDTO> getSkuDetails(String bbbChannel, String siteId, List<String> childSkus) ;
}
|
package com.ntxdev.zuptecnico;
import android.support.v7.app.AlertDialog;
import android.app.DatePickerDialog;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.ntxdev.zuptecnico.api.Zup;
import com.ntxdev.zuptecnico.entities.InventoryCategory;
import com.ntxdev.zuptecnico.entities.InventoryCategoryStatus;
import com.ntxdev.zuptecnico.entities.InventoryItemFilter;
import com.ntxdev.zuptecnico.ui.InventoryItemFilterViewController;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Iterator;
public class AdvancedSearchActivity extends AppCompatActivity
implements DatePickerDialog.OnDateSetListener
{
public static final int REQUEST_SEARCH = 1;
public static final int RESULT_SEARCH = 1;
private int categoryId;
private ArrayList<InventoryItemFilterViewController> filters;
public void onCreate(Bundle savedInstance)
{
super.onCreate(savedInstance);
this.setContentView(R.layout.activity_inventory_items_advancedsearch);
Zup.getInstance().initStorage(getApplicationContext());
Intent intent = getIntent();
int categoryId = intent.getIntExtra("categoryId", -1);
if(categoryId == -1)
return;
this.categoryId = categoryId;
filters = new ArrayList<InventoryItemFilterViewController>();
ViewGroup statusesContainer = (ViewGroup)findViewById(R.id.advancedsearch_status_container);
Iterator<InventoryCategoryStatus> statuses = Zup.getInstance().getInventoryCategoryStatusIterator(categoryId);
while(statuses.hasNext())
{
InventoryCategoryStatus status = statuses.next();
CheckBox checkBox = new CheckBox(this);
checkBox.setText(status.title);
checkBox.setTag(status);
statusesContainer.addView(checkBox);
}
View.OnClickListener pickDateOnClickListener = new View.OnClickListener() {
@Override
public void onClick(View view) {
pickDate((ViewGroup)view, (Calendar)view.getTag());
}
};
findViewById(R.id.creation_date_from_field).setOnClickListener(pickDateOnClickListener);
findViewById(R.id.creation_date_to_field).setOnClickListener(pickDateOnClickListener);
findViewById(R.id.modification_date_from_field).setOnClickListener(pickDateOnClickListener);
findViewById(R.id.modification_date_to_field).setOnClickListener(pickDateOnClickListener);
loadPreviousData();
buildPage();
}
void loadPreviousData()
{
ViewGroup statusesContainer = (ViewGroup)findViewById(R.id.advancedsearch_status_container);
if(getIntent().hasExtra("search_data"))
{
Intent searchData = (Intent)getIntent().getExtras().get("search_data");
if(searchData.hasExtra("name"))
((EditText)findViewById(R.id.advancedsearch_name)).setText(searchData.getStringExtra("name"));
if(searchData.hasExtra("creation_from"))
{
ViewGroup container = (ViewGroup)findViewById(R.id.creation_date_from_field);
Calendar date = (Calendar)searchData.getExtras().get("creation_from");
container.setTag(date);
findFirstChildOfType(container, TextView.class).setText(Zup.getInstance().getDateFormat().format(date.getTime()));
}
if(searchData.hasExtra("creation_to"))
{
ViewGroup container = (ViewGroup)findViewById(R.id.creation_date_to_field);
Calendar date = (Calendar)searchData.getExtras().get("creation_to");
container.setTag(date);
findFirstChildOfType(container, TextView.class).setText(Zup.getInstance().getDateFormat().format(date.getTime()));
}
if(searchData.hasExtra("modification_from"))
{
ViewGroup container = (ViewGroup)findViewById(R.id.modification_date_from_field);
Calendar date = (Calendar)searchData.getExtras().get("modification_from");
container.setTag(date);
findFirstChildOfType(container, TextView.class).setText(Zup.getInstance().getDateFormat().format(date.getTime()));
}
if(searchData.hasExtra("modification_to"))
{
ViewGroup container = (ViewGroup)findViewById(R.id.modification_date_to_field);
Calendar date = (Calendar)searchData.getExtras().get("modification_to");
container.setTag(date);
findFirstChildOfType(container, TextView.class).setText(Zup.getInstance().getDateFormat().format(date.getTime()));
}
if(searchData.hasExtra("statuses"))
{
Object[] search_statuses = (Object[])searchData.getExtras().get("statuses");
ArrayList<Integer> statuses = new ArrayList<Integer>();
for(Object statusId : search_statuses)
{
statuses.add((Integer)statusId);
}
for(int i = 0; i < statusesContainer.getChildCount(); i++)
{
if(!(statusesContainer.getChildAt(i) instanceof CheckBox))
continue;
CheckBox checkBox = (CheckBox)statusesContainer.getChildAt(i);
InventoryCategoryStatus status = (InventoryCategoryStatus)checkBox.getTag();
if(statuses.contains(status.id))
checkBox.setChecked(true);
}
}
if(searchData.hasExtra("latitude"))
((EditText)findViewById(R.id.advancedsearch_latitude)).setText(searchData.getStringExtra("latitude"));
if(searchData.hasExtra("longitude"))
((EditText)findViewById(R.id.advancedsearch_longitude)).setText(searchData.getStringExtra("longitude"));
if(searchData.hasExtra("address"))
((EditText)findViewById(R.id.advancedsearch_address)).setText(searchData.getStringExtra("address"));
}
}
class PageBuilder extends AsyncTask<Void, Void, View[]>
{
ViewGroup container;
public PageBuilder(ViewGroup container)
{
this.container = container;
}
@Override
protected void onPreExecute() {
container.removeAllViews();
filters.clear();
ProgressBar bar = new ProgressBar(container.getContext());
bar.setIndeterminate(true);
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
params.gravity = Gravity.CENTER_HORIZONTAL;
params.topMargin = 100;
params.bottomMargin = 100;
bar.setLayoutParams(params);
container.addView(bar);
}
@Override
protected View[] doInBackground(Void... voids) {
return buildPageB();
}
@Override
protected void onPostExecute(View[] views) {
container.removeAllViews();
for(View v : views)
{
container.addView(v);
}
}
}
void buildPage()
{
ViewGroup container = (ViewGroup)findViewById(R.id.items_search_container);
PageBuilder builder = new PageBuilder(container);
builder.execute();
}
private View[] buildPageB()
{
//ViewGroup container = (ViewGroup)findViewById(R.id.items_search_container);
InventoryCategory category = Zup.getInstance().getInventoryCategory(this.categoryId);
ArrayList<View> result = new ArrayList<View>();
//container.removeAllViews();
//filters.clear();
if(category.sections != null)
{
Arrays.sort(category.sections, new Comparator<InventoryCategory.Section>() {
@Override
public int compare(InventoryCategory.Section section, InventoryCategory.Section section2) {
int pos1 = 0;
int pos2 = 0;
if (section.position != null) {
pos1 = section.position;
}
if (section2.position != null) {
pos2 = section2.position;
}
if (section.position == null)
pos1 = pos2;
if (section2.position == null)
pos2 = pos1;
if (pos1 < pos2)
return -1;
else if (pos1 == pos2)
return 0;
else
return 1;
}
});
for(InventoryCategory.Section section : category.sections)
{
for(InventoryCategory.Section.Field field : section.fields)
{
ViewGroup vg = (ViewGroup) getLayoutInflater().inflate(R.layout.inventory_item_item_filter, null);
//container.addView(vg);
result.add(vg);
InventoryItemFilterViewController vc = new InventoryItemFilterViewController(vg, field, this);
filters.add(vc);
if(getIntent().hasExtra("search_data"))
{
Intent searchData = (Intent) getIntent().getExtras().get("search_data");
if (searchData.hasExtra("filter_" + field.id + "_type"))
{
Object first = searchData.getExtras().get("filter_" + field.id + "_first");
Object second = searchData.getExtras().get("filter_" + field.id + "_second");
vc.setType((InventoryItemFilterViewController.FilterType) searchData.getExtras().get("filter_" + field.id + "_type"));
vc.setValues(first, second);
vc.setEnabled(true);
}
else
{
vc.setEnabled(false);
}
}
}
}
}
View[] resultarr = new View[result.size()];
result.toArray(resultarr);
return resultarr;
}
private void pickDate(ViewGroup fieldContainer, Calendar date)
{
if(date == null)
date = Calendar.getInstance();
DatePickerDialog dialog = new DatePickerDialog(this, this, date.get(Calendar.YEAR), date.get(Calendar.MONTH), date.get(Calendar.DAY_OF_MONTH));
dialog.getDatePicker().setTag(R.id.tag_item_id, fieldContainer.getId());
dialog.show();
}
public void cancel(View view)
{
finish();
overridePendingTransition(R.anim.hold, R.anim.slide_out_bottom);
}
public void search(View view)
{
Calendar creation_from = (Calendar)findViewById(R.id.creation_date_from_field).getTag();
Calendar creation_to = (Calendar)findViewById(R.id.creation_date_to_field).getTag();
Calendar modification_from = (Calendar)findViewById(R.id.modification_date_from_field).getTag();
Calendar modification_to = (Calendar)findViewById(R.id.modification_date_to_field).getTag();
if(creation_from != null && creation_to != null && creation_from.getTime().compareTo(creation_to.getTime()) > 0) // from > to
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Erro");
builder.setMessage("O campo da data de criação 'a partir de' deve ser menor que o campo 'até'");
builder.show();
return;
}
else if(modification_from != null && modification_to != null && modification_from.getTime().compareTo(modification_to.getTime()) > 0)
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Erro");
builder.setMessage("O campo da data de modificação 'a partir de' deve ser menor que o campo 'até'");
builder.show();
return;
}
ArrayList<Integer> raw_statuses = new ArrayList<Integer>();
ViewGroup statusesContainer = (ViewGroup)findViewById(R.id.advancedsearch_status_container);
for(int i = 0; i < statusesContainer.getChildCount(); i++)
{
if(!(statusesContainer.getChildAt(i) instanceof CheckBox))
continue;
CheckBox checkBox = (CheckBox)statusesContainer.getChildAt(i);
if(checkBox.isChecked())
{
InventoryCategoryStatus status = (InventoryCategoryStatus)checkBox.getTag();
if(status != null)
raw_statuses.add(status.id);
}
}
String raw_name = ((EditText)findViewById(R.id.advancedsearch_name)).getText().toString();
String raw_latitude = ((EditText)findViewById(R.id.advancedsearch_latitude)).getText().toString();
String raw_longitude = ((EditText)findViewById(R.id.advancedsearch_longitude)).getText().toString();
String raw_address = ((EditText)findViewById(R.id.advancedsearch_address)).getText().toString();
Intent intent = new Intent();
if(!raw_name.equals(""))
intent.putExtra("name", raw_name);
if(creation_from != null)
intent.putExtra("creation_from", creation_from);
if(creation_to != null)
intent.putExtra("creation_to", creation_to);
if(modification_from != null)
intent.putExtra("modification_from", modification_from);
if(modification_to != null)
intent.putExtra("modification_to", modification_to);
if(!raw_latitude.equals(""))
intent.putExtra("latitude", raw_latitude);
if(!raw_longitude.equals(""))
intent.putExtra("longitude", raw_longitude);
if(!raw_address.equals(""))
intent.putExtra("address", raw_address);
if(raw_statuses.size() > 0)
intent.putExtra("statuses", (Integer[])raw_statuses.toArray(new Integer[0]));
int i = 0;
for(InventoryItemFilterViewController filter : filters)
{
if(filter.isEnabled())
{
Object[] values = filter.getValues();
InventoryItemFilter f = new InventoryItemFilter();
f.fieldId = filter.getField().id;
f.type = filter.getTypeString();
f.value1 = (Serializable) values[0];
f.value2 = (Serializable) values[1];
f.isArray = filter.isArray();
intent.putExtra("filter" + (i++), f);
intent.putExtra("filter_" + filter.getField().id + "_type", filter.getType());
intent.putExtra("filter_" + filter.getField().id + "_first", (Serializable) values[0]);
intent.putExtra("filter_" + filter.getField().id + "_second", (Serializable) values[1]);
}
}
intent.putExtra("categoryId", this.categoryId);
this.setResult(RESULT_SEARCH, intent);
finish();
overridePendingTransition(R.anim.hold, R.anim.slide_out_bottom);
}
@Override
public void onDateSet(DatePicker datePicker, int i, int i2, int i3)
{
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, i);
calendar.set(Calendar.MONTH, i2);
calendar.set(Calendar.DAY_OF_MONTH, i3);
ViewGroup fieldContainer = (ViewGroup)findViewById((Integer)datePicker.getTag(R.id.tag_item_id));
fieldContainer.setTag(calendar);
TextView textView = findFirstChildOfType(fieldContainer, TextView.class);
textView.setText(Zup.getInstance().getDateFormat().format(calendar.getTime()));
}
private <T> T findFirstChildOfType(ViewGroup container, Class<T> objectClass)
{
for(int i = 0; i < container.getChildCount(); i++)
{
View child = container.getChildAt(i);
if(objectClass.isInstance(child))
return (T)child;
}
return null;
}
}
|
package pe.gob.trabajo.repository;
import pe.gob.trabajo.domain.Bensocial;
import org.springframework.stereotype.Repository;
import org.springframework.data.jpa.repository.*;
import java.util.List;
/**
* Spring Data JPA repository for the Bensocial entity.
*/
@SuppressWarnings("unused")
@Repository
public interface BensocialRepository extends JpaRepository<Bensocial, Long> {
@Query("select bensocial from Bensocial bensocial where bensocial.nFlgactivo = true")
List<Bensocial> findAll_Activos();
@Query("select bensocial from Bensocial bensocial where bensocial.vBensocial=?1 and bensocial.nFlgactivo = true")
Bensocial find_Bensocial_ByNombre(String nombensocial);
}
|
/*
* The MIT License
*
* Copyright 2019 tibo.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package be.cylab.mark.activation;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import be.cylab.mark.server.Config;
import java.util.HashMap;
import java.util.Map;
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteState;
import org.apache.ignite.Ignition;
import org.apache.ignite.cluster.ClusterMetrics;
import org.apache.ignite.configuration.DataStorageConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.spi.collision.fifoqueue.FifoQueueCollisionSpi;
import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
/**
* Allows to run our detection jobs using an Apache Ignite cluster.
* @author tibo
*/
@Singleton
public final class IgniteExecutor implements ExecutorInterface {
private final Ignite ignite;
private final Config config;
private static final String LOCALHOST = "127.0.0.1";
/**
*
* @param config
*/
@Inject
public IgniteExecutor(final Config config) {
this.config = config;
if (Ignition.state() == IgniteState.STARTED) {
ignite = Ignition.ignite();
return;
}
IgniteConfiguration ignite_config = new IgniteConfiguration();
ignite_config.setPeerClassLoadingEnabled(true);
ignite_config.setClientMode(!config.isIgniteStartServer());
ignite_config.setCollisionSpi(new FifoQueueCollisionSpi());
ignite_config.setMetricsUpdateFrequency(500);
// Changing total RAM size to be used by Ignite Node.
DataStorageConfiguration storage_config =
new DataStorageConfiguration();
storage_config.getDefaultDataRegionConfiguration().setMaxSize(
12L * 1024 * 1024 * 1024);
ignite_config.setDataStorageConfiguration(storage_config);
if (!config.isIgniteAutodiscovery()) {
// Disable autodiscovery
TcpDiscoverySpi spi = new TcpDiscoverySpi();
TcpDiscoveryVmIpFinder ip_finder = new TcpDiscoveryVmIpFinder();
ip_finder.setAddresses(Arrays.asList(LOCALHOST));
spi.setIpFinder(ip_finder);
ignite_config.setDiscoverySpi(spi);
}
// Start Ignite framework..
ignite = Ignition.start(ignite_config);
}
@Override
public void submit(final Runnable job) {
this.ignite.executorService().submit(job);
}
@Override
public boolean shutdown() throws InterruptedException {
Thread.sleep(2 * 1000 * config.getUpdateInterval());
this.ignite.executorService().shutdown();
return this.ignite.executorService().awaitTermination(1, TimeUnit.DAYS);
}
@Override
public Map<String, Object> getStatus() {
HashMap<String, Object> map = new HashMap<>();
ClusterMetrics metrics = ignite.cluster().metrics();
map.put("executor.job.executed", metrics.getTotalExecutedJobs());
map.put("executor.job.running", metrics.getCurrentActiveJobs());
map.put("executor.job.waiting", metrics.getCurrentWaitingJobs());
map.put("executor.job.waittime", metrics.getAverageJobWaitTime());
map.put("executor.job.executetime", metrics.getAverageJobExecuteTime());
map.put("executor.nodes", metrics.getTotalNodes());
map.put("executor.cpus", metrics.getTotalCpus());
return map;
}
}
|
package com.ifli.mbcp.domain;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
* Represents a child - son or daughter.
*
* @author FL703
* @version 1.0
* @since 09 May 2013
*/
@Entity
@Table(name = "tbl_child")
public class Child extends Person implements Serializable
{
private static final long serialVersionUID = 7690957457776126172L;
private Long childId;
private Relationship relationship;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(unique = true, nullable = false)
public Long getChildId()
{
return childId;
}
public void setChildId(Long childId)
{
this.childId = childId;
}
@OneToOne
@JoinColumn(name = "relationshipId", nullable = false)
public Relationship getRelationship()
{
return relationship;
}
public void setRelationship(Relationship relationship)
{
this.relationship = relationship;
}
@Override
@Column(length = 30, nullable = false)
public String getFirstName()
{
return super.getFirstName();
}
@Override
@Column(length = 30)
public String getMiddleName()
{
return super.getMiddleName();
}
@Override
@Column(length = 30, nullable = false)
public String getLastName()
{
return super.getLastName();
}
@Override
@JoinColumn(name = "salutationId", nullable = false)
public Salutation getSalutation()
{
return super.getSalutation();
}
@Override
@Column(nullable = false)
public Date getDateOfBirth()
{
return super.getDateOfBirth();
}
} |
package br.com.luvva.challenge.common.service;
import br.com.luvva.challenge.common.model.Account;
import br.com.luvva.challenge.common.model.Digit;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import static br.com.luvva.challenge.common.model.Digit.*;
/**
* Central location for the settings and parameters that defines the expected format of the file generated by the
* machine.
*
* @author Amsterdam Luís
*/
public class SettingsService
{
/**
* The characted quantity in each line of the file.
*/
public static final int CHARACTER_QUANTITY_PER_LINE = 27;
/**
* The quantity of digits that a valid account has.
*/
public static final int ACCOUNT_DIGITS_QUANTITY = 9;
/**
* The quantity of characters needed to represent a digit in the format generated by the machine.
*/
public static final int CHARACTER_QUANTITY_BY_DIGIT = 7;
/**
* The character that represents an illegile digit.
*/
public static final String ILLEGIBLE_DIGIT_IDENTIFIER = "?";
/**
* Checks if an account is valid.
*
* @param account the account.
* @return true if the account is valid.
*/
public boolean isValid (String account)
{
List<Integer> digits = new ArrayList<>();
for (Optional<Digit> digit : convert(account))
{
if (digit.isPresent())
{
digits.add(digit.get().asInt());
}
else
{
return false;
}
}
int weightedSum = 0;
for (int i = 0; i < digits.size(); i++)
{
weightedSum += digits.get(i) * (digits.size() - i);
}
return weightedSum % 11 == 0;
}
private Account convert (String account)
{
Objects.requireNonNull(account);
if (!account.matches("[0-9" + ILLEGIBLE_DIGIT_IDENTIFIER + "]{" + ACCOUNT_DIGITS_QUANTITY + "}"))
{
throw new IllegalArgumentException();
}
char[] chars = account.toCharArray();
Digit[] digits = new Digit[chars.length];
for (int i = 0; i < chars.length; i++)
{
if (!ILLEGIBLE_DIGIT_IDENTIFIER.equals(String.valueOf(chars[i])))
{
digits[i] = convert(chars[i]);
}
}
return new Account(digits);
}
private Digit convert (char digit)
{
switch (digit)
{
case '0':
return ZERO;
case '1':
return ONE;
case '2':
return TWO;
case '3':
return THREE;
case '4':
return FOUR;
case '5':
return FIVE;
case '6':
return SIX;
case '7':
return SEVEN;
case '8':
return EIGHT;
case '9':
return NINE;
default:
throw new IllegalArgumentException();
}
}
}
|
package com.shagaba.kickstarter.auth.core.domain.security.account;
import org.springframework.stereotype.Component;
import com.shagaba.kickstarter.auth.core.common.domain.AbstractEntityGenerator;
@Component
public class UserAccountEntityGenerator extends AbstractEntityGenerator<UserAccount, String> {
@Override
public Class<UserAccount> entityClass() {
return UserAccount.class;
}
@Override
public void update(UserAccount entity, String tag) {
if (tag != null && !tag.isEmpty()) {
entity.setSalt(tag);
entity.setEmailAddress(tag);
}
}
@Override
public String getId(UserAccount entity) {
return entity.getAccountId();
}
}
|
package com.artezio.bpm.camunda.mailing;
import org.apache.tika.Tika;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.annotation.Resource;
import javax.inject.Inject;
import javax.inject.Named;
import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.util.ByteArrayDataSource;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static java.nio.charset.StandardCharsets.UTF_8;
import static javax.mail.Message.RecipientType.*;
@Named
public class MailSenderDelegate implements JavaDelegate {
@Inject
private MailTemplateManager mailTemplateManager;
@Resource(mappedName = "java:global/camunda-bpm-platform/mail/com.artezio.bpm.camunda")
private Session session;
private Tika tika = new Tika();
public void execute(DelegateExecution execution) throws Exception {
MimeMessage mimeMessage = createMimeMessage(execution);
Transport.send(mimeMessage);
}
private MimeMessage createMimeMessage(DelegateExecution execution) throws MessagingException {
MimeMessage mimeMessage = new MimeMessage(session);
mimeMessage.setSentDate(new Date());
addSenderAndRecipients(mimeMessage, execution);
addContent(mimeMessage, execution);
return mimeMessage;
}
private void addSenderAndRecipients(MimeMessage mimeMessage, DelegateExecution execution) throws MessagingException {
String sender = (String) execution.getVariable("mailSender");
String recipients = (String) execution.getVariable("mailRecipients");
Optional<String> ccRecipients = Optional.ofNullable((String) execution.getVariable("mailCcRecipients"));
Optional<String> bccRecipients = Optional.ofNullable((String) execution.getVariable("mailBccRecipients"));
mimeMessage.setFrom(new InternetAddress(sender));
addRecipient(mimeMessage, TO, recipients);
ccRecipients.ifPresent(value -> addRecipient(mimeMessage, CC, value));
bccRecipients.ifPresent(value -> addRecipient(mimeMessage, BCC, value));
}
private void addRecipient(MimeMessage mimeMessage, Message.RecipientType recipientType, String recipients) {
try {
mimeMessage.addRecipients(recipientType, InternetAddress.parse(recipients, false));
} catch (MessagingException e) {
throw new RuntimeException("Error while forming mail recipient list.", e);
}
}
private void addContent(MimeMessage mimeMessage, DelegateExecution execution) throws MessagingException {
String mailTemplate = (String) execution.getVariable("mailTemplate");
Map<String, Object> mailProperties = execution.getVariables();
String mailSubjectText = mailTemplateManager.getTemplateText(execution, mailTemplate + "_subject.ftl", mailProperties);
String mailBodyText = mailTemplateManager.getTemplateText(execution, mailTemplate + "_body.ftl", mailProperties);
mimeMessage.setSubject(mailSubjectText, UTF_8.name());
MimeMultipart messageMultipartData = new MimeMultipart("related");
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent(mailBodyText, "text/html");
messageMultipartData.addBodyPart(messageBodyPart);
Optional<List<String>> mailImageNames = Optional.ofNullable((List<String>) mailProperties.get("mailImageNames"));
mailImageNames.ifPresent(value ->
value.forEach(mailImageName -> addImage(mailImageName, messageMultipartData, execution)));
mimeMessage.setContent(messageMultipartData);
}
private void addImage(String mailImageName, MimeMultipart multipart, DelegateExecution execution) {
BodyPart messageImagePart = new MimeBodyPart();
try(InputStream mailImage = mailTemplateManager.getMailImage(execution, mailImageName)) {
String mailImageType = tika.detect(mailImage);
DataSource fds = new ByteArrayDataSource(mailImage, mailImageType);
messageImagePart.setDataHandler(new DataHandler(fds));
messageImagePart.setHeader("Content-ID", "<" + mailImageName + ">");
multipart.addBodyPart(messageImagePart);
} catch (MessagingException | IOException e) {
throw new RuntimeException("Error while creating message content", e);
}
}
}
|
package com.xvr.serviceBook.form;
import lombok.*;
import org.springframework.hateoas.server.core.Relation;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
@Data
@Getter
@Setter
@Builder
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Relation(collectionRelation = "department")
public class DepartmentForm {
@NotNull
@Min(1)
private Long id;
@NotEmpty
private String name;
}
|
package com.zp.test;
import com.zp.DeliverApplication8091;
import com.zp.feignclient.ResumeFeignClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DeliverApplication8091.class)
public class FeignTest {
@Autowired
ResumeFeignClient feignClient;
@Test
public void feignTest() {
Integer port = feignClient.findDefaultResumeState(2195321L);
System.out.println("测试的结果" + port);
}
}
|
package com.example.demo.Mappers;
import com.example.demo.domain.Open;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
public interface OpenMapper {
public List<Map> getByGh(String gh);
public Open getByKhGhXq(String kh,String gh,String xq);
public List<Map> getAll();
public List<Map> getelenum();
/**
* 查询选了某一课程的所有学生及他们的成绩信息
*/
public List<Map> getDetail(String kh,String gh,String xq);
public boolean insert(@Param("xq") String xq, @Param("kh") String kh, @Param("gh") String gh, @Param("sksj") String sksj, @Param("max") Integer max);
public boolean update(@Param("xq") String xq, @Param("kh") String kh, @Param("gh") String gh, @Param("sksj") String sksj, @Param("max") Integer max);
public List<Map> search(String inputStr);
}
|
package webserver;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ServerConfig {
private Path directory;
private Map<String, String> mimeTypes;
private Map<MappingInfo, HandlerInfo> dynamicResponseURIs = new HashMap<>();
private List<Filter> filters;
private Map<String, Object> attributes = new HashMap<>();
public ServerConfig(Path directory, Map<String, String> mimeTypes, List<Filter> filters) {
this.directory = directory;
this.mimeTypes = mimeTypes;
this.filters = filters;
}
public Map<String, String> getMimeTypes() {
return mimeTypes;
}
public Map<MappingInfo, HandlerInfo> getDynamicResponseURIs() {
return dynamicResponseURIs;
}
public Path getDirectory() {
return directory;
}
public List<Filter> getFilters() {
return filters;
}
public Map<String, Object> getAttributes() {
return attributes;
}
}
|
package com.google.android.exoplayer2.a;
import com.google.android.exoplayer2.i.a;
import com.tencent.mm.plugin.game.gamewebview.jsapi.biz.b;
import java.util.Arrays;
final class k {
float aex;
short[] ahA;
private int ahB;
short[] ahC;
private int ahD;
private short[] ahE;
private int ahF;
private int ahG;
int ahH;
int ahI;
int ahJ;
int ahK;
private int ahL;
private int ahM;
private int ahN;
private int ahO;
final int ahu;
private final int ahv;
private final int ahw;
final int ahx = (this.ahw * 2);
private final short[] ahy = new short[this.ahx];
private int ahz = this.ahx;
float pitch;
private final int sampleRate;
public k(int i, int i2) {
this.sampleRate = i;
this.ahu = i2;
this.ahv = i / 400;
this.ahw = i / 65;
this.ahA = new short[(this.ahx * i2)];
this.ahB = this.ahx;
this.ahC = new short[(this.ahx * i2)];
this.ahD = this.ahx;
this.ahE = new short[(this.ahx * i2)];
this.ahF = 0;
this.ahG = 0;
this.ahL = 0;
this.aex = 1.0f;
this.pitch = 1.0f;
}
private void cd(int i) {
if (this.ahI + i > this.ahB) {
this.ahB += (this.ahB / 2) + i;
this.ahC = Arrays.copyOf(this.ahC, this.ahB * this.ahu);
}
}
final void ce(int i) {
if (this.ahH + i > this.ahz) {
this.ahz += (this.ahz / 2) + i;
this.ahA = Arrays.copyOf(this.ahA, this.ahz * this.ahu);
}
}
private void a(short[] sArr, int i, int i2) {
cd(i2);
System.arraycopy(sArr, this.ahu * i, this.ahC, this.ahI * this.ahu, this.ahu * i2);
this.ahI += i2;
}
private void b(short[] sArr, int i, int i2) {
int i3 = this.ahx / i2;
int i4 = this.ahu * i2;
int i5 = i * this.ahu;
for (int i6 = 0; i6 < i3; i6++) {
int i7 = 0;
for (int i8 = 0; i8 < i4; i8++) {
i7 += sArr[((i6 * i4) + i5) + i8];
}
this.ahy[i6] = (short) (i7 / i4);
}
}
private int a(short[] sArr, int i, int i2, int i3) {
int i4 = b.CTRL_BYTE;
int i5 = 1;
int i6 = i * this.ahu;
int i7 = 0;
int i8 = 0;
int i9 = i2;
while (i9 <= i3) {
int i10 = 0;
for (int i11 = 0; i11 < i9; i11++) {
i10 += Math.abs(sArr[i6 + i11] - sArr[(i6 + i9) + i11]);
}
if (i10 * i8 < i5 * i9) {
i5 = i10;
i8 = i9;
}
if (i10 * i4 > i7 * i9) {
i4 = i9;
} else {
i10 = i7;
}
i9++;
i7 = i10;
}
this.ahN = i5 / i8;
this.ahO = i7 / i4;
return i8;
}
final void jw() {
int i;
int min;
int a;
int i2;
short[] sArr;
int i3 = this.ahI;
float f = this.aex / this.pitch;
if (((double) f) <= 1.00001d && ((double) f) >= 0.99999d) {
a(this.ahA, 0, this.ahH);
this.ahH = 0;
} else if (this.ahH >= this.ahx) {
int i4 = this.ahH;
i = 0;
do {
if (this.ahK > 0) {
min = Math.min(this.ahx, this.ahK);
a(this.ahA, i, min);
this.ahK -= min;
i += min;
} else {
short[] sArr2 = this.ahA;
min = this.sampleRate > 4000 ? this.sampleRate / 4000 : 1;
if (this.ahu == 1 && min == 1) {
min = a(sArr2, i, this.ahv, this.ahw);
} else {
b(sArr2, i, min);
a = a(this.ahy, 0, this.ahv / min, this.ahw / min);
if (min != 1) {
i2 = a * min;
a = i2 - (min * 4);
i2 += min * 4;
if (a < this.ahv) {
min = this.ahv;
} else {
min = a;
}
if (i2 > this.ahw) {
a = this.ahw;
} else {
a = i2;
}
if (this.ahu == 1) {
min = a(sArr2, i, min, a);
} else {
b(sArr2, i, 1);
min = a(this.ahy, 0, min, a);
}
} else {
min = a;
}
}
a = this.ahN;
Object obj = (a == 0 || this.ahL == 0) ? null : this.ahO > a * 3 ? null : a * 2 <= this.ahM * 3 ? null : 1;
int i5 = obj != null ? this.ahL : min;
this.ahM = this.ahN;
this.ahL = min;
if (((double) f) > 1.0d) {
sArr = this.ahA;
if (f >= 2.0f) {
min = (int) (((float) i5) / (f - 1.0f));
} else {
this.ahK = (int) ((((float) i5) * (2.0f - f)) / (f - 1.0f));
min = i5;
}
cd(min);
a(min, this.ahu, this.ahC, this.ahI, sArr, i, sArr, i + i5);
this.ahI += min;
i += min + i5;
} else {
int i6;
Object obj2 = this.ahA;
if (f < 0.5f) {
i6 = (int) ((((float) i5) * f) / (1.0f - f));
} else {
this.ahK = (int) ((((float) i5) * ((2.0f * f) - 1.0f)) / (1.0f - f));
i6 = i5;
}
cd(i5 + i6);
System.arraycopy(obj2, this.ahu * i, this.ahC, this.ahI * this.ahu, this.ahu * i5);
a(i6, this.ahu, this.ahC, this.ahI + i5, obj2, i + i5, obj2, i);
this.ahI += i5 + i6;
i += i6;
}
}
} while (this.ahx + i <= i4);
min = this.ahH - i;
System.arraycopy(this.ahA, this.ahu * i, this.ahA, 0, this.ahu * min);
this.ahH = min;
}
if (this.pitch != 1.0f) {
float f2 = this.pitch;
if (this.ahI != i3) {
int i7;
a = (int) (((float) this.sampleRate) / f2);
min = this.sampleRate;
while (true) {
i2 = min;
i7 = a;
if (i7 <= 16384 && i2 <= 16384) {
break;
}
a = i7 / 2;
min = i2 / 2;
}
min = this.ahI - i3;
if (this.ahJ + min > this.ahD) {
this.ahD += (this.ahD / 2) + min;
this.ahE = Arrays.copyOf(this.ahE, this.ahD * this.ahu);
}
System.arraycopy(this.ahC, this.ahu * i3, this.ahE, this.ahJ * this.ahu, this.ahu * min);
this.ahI = i3;
this.ahJ = min + this.ahJ;
min = 0;
while (true) {
a = min;
if (a >= this.ahJ - 1) {
break;
}
while ((this.ahF + 1) * i7 > this.ahG * i2) {
cd(1);
for (min = 0; min < this.ahu; min++) {
sArr = this.ahC;
i = (this.ahI * this.ahu) + min;
short[] sArr3 = this.ahE;
int i8 = (this.ahu * a) + min;
short s = sArr3[i8];
short s2 = sArr3[i8 + this.ahu];
int i9 = (this.ahF + 1) * i7;
i8 = i9 - (this.ahG * i2);
int i10 = i9 - (this.ahF * i7);
sArr[i] = (short) (((s2 * (i10 - i8)) + (s * i8)) / i10);
}
this.ahG++;
this.ahI++;
}
this.ahF++;
if (this.ahF == i2) {
this.ahF = 0;
a.ap(this.ahG == i7);
this.ahG = 0;
}
min = a + 1;
}
min = this.ahJ - 1;
if (min != 0) {
System.arraycopy(this.ahE, this.ahu * min, this.ahE, 0, (this.ahJ - min) * this.ahu);
this.ahJ -= min;
}
}
}
}
private static void a(int i, int i2, short[] sArr, int i3, short[] sArr2, int i4, short[] sArr3, int i5) {
for (int i6 = 0; i6 < i2; i6++) {
int i7 = (i3 * i2) + i6;
int i8 = (i5 * i2) + i6;
int i9 = (i4 * i2) + i6;
for (int i10 = 0; i10 < i; i10++) {
sArr[i7] = (short) (((sArr2[i9] * (i - i10)) + (sArr3[i8] * i10)) / i);
i7 += i2;
i9 += i2;
i8 += i2;
}
}
}
}
|
package com.dimple.web.controller.maintenance;
import com.dimple.maintenance.domain.EamsConfig;
import com.dimple.maintenance.service.EamsConfigService;
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.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
/**
* 评优评奖配置(EamsConfig)表控制层
*
* @author makejava
* @since 2019-05-08 14:06:39
*/
@Controller
@RequestMapping("/maintenance/config")
public class EamsConfigController {
@Autowired
private EamsConfigService configService;
@RequiresPermissions("maintenance:confiig:view")
@GetMapping()
public String config(Model model) {
List<EamsConfig> configs = configService.selectConfigList();
model.addAttribute("configs", configs);
return "maintenance/config/config";
}
} |
package com.example.hrserver.serviceImpl;/**
* @author ljt
* @Title: MenuServiceImpl
* @ProjectName hrserver
* @Description:
* @Version:
* @date 2019/11/7 16:24
*/
import com.example.hrserver.dao.MenuMapper;
import com.example.hrserver.entity.Menu;
import com.example.hrserver.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Transactional
@CacheConfig(cacheNames = "menus_cache")
@Service
public class MenuServiceImpl implements MenuService {
@Autowired
private MenuMapper menuMapper;
@Cacheable(key = "#root.methodName")
@Override
public List<Menu> getAllMenu() {
return menuMapper.getAllMenu();
}
}
|
package net.tyas.laundry.ui.main.home;
import net.tyas.laundry.ui.base.MvpPresenter;
public interface HomeMvpPresenter<V extends HomeView> extends MvpPresenter<V> {
void getCategories();
}
|
package chapter13.Exercise13_17;
import java.util.Scanner;
public class TestExercise13_17 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter the first complex number: ");
Complex c1 = new Complex(input.nextDouble(), input.nextDouble());
System.out.println("Enter the second complex number: ");
Complex c2 = new Complex(input.nextDouble(), input.nextDouble());
System.out.println(c1 + " + " + c2 + " = " + c1.add(c2));
System.out.println(c1 + " - " + c2 + " = " + c1.subtract(c2));
System.out.println(c1 + " * " + c2 + " = " + c1.multiply(c2));
System.out.println(c1 + " / " + c2 + " = " + c1.divide(c2));
System.out.println("|" + c1 + "| = " + c1.abs());
}
}
|
package com.cnk.travelogix.suppliers.air.service.test;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.cnk.travelogix.suppliers.air.data.AirAvailRQ;
import com.cnk.travelogix.suppliers.air.data.AirAvailRequest;
import com.cnk.travelogix.suppliers.air.data.AirAvailRequestWrapper;
import com.cnk.travelogix.suppliers.air.data.AirAvailResponseWrapper;
import com.cnk.travelogix.suppliers.air.data.OriginDestinationInformation;
import com.cnk.travelogix.suppliers.air.service.SupplierAirService;
import com.cnk.travelogix.suppliers.common.data.Credential;
import com.cnk.travelogix.suppliers.common.data.Credentials;
import com.cnk.travelogix.suppliers.common.data.OperationURL;
import com.cnk.travelogix.suppliers.common.data.POSType;
import com.cnk.travelogix.suppliers.common.data.RequestHeader;
import com.cnk.travelogix.suppliers.common.data.SourceType;
import com.cnk.travelogix.suppliers.common.data.SupplierCredentials;
import com.cnk.travelogix.suppliers.common.data.SupplierID;
/**
* @author I077988
*
*/
public class AirAvailTest {
/**
* @param args
*/
public static void main(String[] args) {
@SuppressWarnings("resource")
ApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] { "suppliers-spring.xml" });
SupplierAirService airService = (SupplierAirService) appContext.getBean("supplierAirService");
final AirAvailRequestWrapper airAvailRequestWrapper = new AirAvailRequestWrapper();
RequestHeader requestHeader = new RequestHeader();
requestHeader.setSessionID("20160717T1347");
requestHeader.setUserID("Venkatesh");
requestHeader.setTransactionID("1347");
Map<String, String> credentialsMap = new HashMap<String, String>();
credentialsMap.put("Username", "1000");
credentialsMap.put("Password", "table55");
credentialsMap.put("Organization", "L7H8");
credentialsMap.put("PseudoCityCode", "L7H8");
credentialsMap.put("CompanyCode", "TN");
List<SupplierCredentials> supplierCredentials = new ArrayList<SupplierCredentials>();
SupplierCredentials supplierCredential = new SupplierCredentials();
SupplierID supplierIDHeader = new SupplierID();
supplierIDHeader.setValue("SABRE");
supplierCredential.setSupplierID(supplierIDHeader);
Credentials credentials = new Credentials();
List<Credential> credentialList = new ArrayList<>();
for (final Map.Entry<String, String> keyValueMap : credentialsMap.entrySet()) {
Credential credential = new Credential();
credential.setName(keyValueMap.getKey());
credential.setValue(keyValueMap.getValue());
credentialList.add(credential);
}
credentials.setCredential(credentialList);
List<OperationURL> operationURLList = new ArrayList<>();
OperationURL operationURL = new OperationURL();
operationURL.setValue("https://sws3-crt.cert.sabre.com/");
operationURL.setOperation("all");
operationURLList.add(operationURL);
credentials.setOperationURL(operationURLList);
supplierCredential.setCredentials(credentials);
supplierCredentials.add(supplierCredential);
requestHeader.setSupplierCredentials(supplierCredentials);
airAvailRequestWrapper.setRequestHeader(requestHeader);
final List<AirAvailRequest> airAvailRequestList = new ArrayList<>();
final AirAvailRequest airAvailRequest = new AirAvailRequest();
final SupplierID supplierID = new SupplierID();
supplierID.setValue("Sabre");
airAvailRequest.setSupplierID(supplierID);
airAvailRequest.setSequence(1);
final AirAvailRQ airAvailRQ = new AirAvailRQ();
airAvailRQ.setVersion(new BigDecimal("1.0"));
airAvailRQ.setTarget("Test");
final POSType posType = new POSType();
List<SourceType> sourceTypeList = new ArrayList<>();
final SourceType sourceType = new SourceType();
sourceTypeList.add(sourceType);
posType.setSource(sourceTypeList);
airAvailRQ.setPos(posType);
final List<OriginDestinationInformation> originDestinationInformationList = new ArrayList<>();
final OriginDestinationInformation originDestinationInformation = new OriginDestinationInformation();
originDestinationInformation.setRph("1");
originDestinationInformation.setDepartureDateTime("2016-07-29");
originDestinationInformation.setDestinationLocationCode("DEL");
originDestinationInformation.setOriginLocationCode("BOM");
originDestinationInformationList.add(originDestinationInformation);
airAvailRQ.setOriginDestinationInformation(originDestinationInformationList);
airAvailRequest.setAirAvailRQ(airAvailRQ);
airAvailRequestList.add(airAvailRequest);
airAvailRequestWrapper.setAirAvailRequest(airAvailRequestList);
final AirAvailResponseWrapper response = airService.otaGetAvailability(airAvailRequestWrapper);
System.out.println("Response : " + response.toString());
System.out.println("Success");
}
}
|
package Server;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.util.List;
import Client.ClientInterface;
import Session.SessionInterface;
import Session.Session;
import java.util.ArrayList;
public class Server extends UnicastRemoteObject implements ServerInterface {
private List sessionList = new ArrayList(); //Liste die mit den einzelnen Sessions gefüllt ist
private String solution;
private String tmpSolution="";
private int lifes=12;
public Server() throws RemoteException {
}
/**
* Startet Server mit Port 2344
* @param args
*/
public static void main(String args[]) {
try {
Registry reg=LocateRegistry.createRegistry(2344);
reg.rebind("Galgenmann", new Server());
} catch(Exception e) {
System.out.println(e.getMessage());
}
}
/**
* Verarbeitet den Lösungsvorschlag und prüft, ob das Wort gefunden wurde. Wenn ja
* wird ein neues Spiel gestartet.
* @param message
* @param s
*/
public void sendAnswer(String message, Session s) {
message=message.toUpperCase();
Session tmpSession;
String tmpSolutionSplit[];
String tmpSolutionSave="";
boolean found=false;
for(int j=0; j < this.sessionList.size(); j++) { //Schreibt nachricht des Nutzers über die verschiedenen Sessions an die einzelnen Clients
tmpSession = (Session)this.sessionList.get(j);
try {
tmpSession.getClientInt().getMessage(s.getName(),message);
} catch(RemoteException e) { //Wenn der Nuter nicht erreicht wird, wird er vom Server geschmissen, indem die Sessions miteinander verglichen werden
Session tmp2Session;
System.out.println(tmpSession.getName()+" ist unerreichbar und wird entfernt...");
for(int i=0; i<sessionList.size();i++) {
tmp2Session=(Session)this.sessionList.get(i);
if(tmp2Session.isEqual(tmpSession)) {
sessionList.remove(i);
}
}
}
}
if(solution!=null){ //Wenn die gespeicherte Lösung ungleich null, also das Spiel begonnen hat
if(message.length()==1) { //Unterscheidung in Buchtsabenvorschläge und Lösungswortvorschläge
char input=message.charAt(0);
suche:
for(int i=0; i<solution.length();i++) { //Geht alle Buchstaben durch und prüft, ob sie im Lösungswort sind
if(input==solution.charAt(i)) {
found=true;
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
tmpSession.getClientInt().getMessage("Answer-Bot", "Richtig: "+message.charAt(0));
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
break suche;
}
}
if(found==true) {
tmpSolutionSplit=tmpSolution.split(" ");
for(int i=0; i<solution.length();i++) { //Füllt die temporäre Lösung mit dem gefundenen Buchstaben
if(input==solution.charAt(i)){
if(!String.valueOf(input).equals(null)) {
tmpSolutionSplit[i]=String.valueOf(input);
}
}
}
for(int k=0; k<tmpSolutionSplit.length;k++) {
tmpSolutionSave+=tmpSolutionSplit[k]+" ";
}
tmpSolution=tmpSolutionSave;
}else { //Wenn der Buchstabe nicht gefunden wurde werden die Leben abgezogen
lifes-=1;
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
tmpSession.getClientInt().getMessage("Answer-Bot", "Falsch: "+ message.charAt(0));
} catch(Exception ex) {
}
}
}
this.showInformation();
}
if(message.length()!=1) {
if(message.equals(solution)) { //Wenn das eingegebene Wort das Lösungswort ist
found=true;
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
if(s.isEqual(tmpSession)) {
tmpSession.getClientInt().newGame(true); //starte neues Spiel als Spielmacher
tmpSession.getClientInt().getMessage("Answer-Bot", "Du hast das Lösungswort "+solution+" erraten!");
}
else {
tmpSession.getClientInt().newGame(false); //starte neues Spiel als Mitspieler
tmpSession.getClientInt().getMessage("Answer-Bot", s.getName()+" hat das Lösungswort "+solution+" erraten!");
}
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
this.reset();
}
else {
lifes-=1;
for(int j=0; j < sessionList.size(); j++) {
tmpSession = (Session)sessionList.get(j);
try {
tmpSession.getClientInt().getMessage("Answer-Bot",message+" ist nicht das Lösungsowrt!");
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
this.showInformation();
}
}
if(solution!=null&&this.isTmpSolutionFilled()) { //Abfrage ungleich null, da nach restart wenn die Lösung gefunden wurde auch null ist
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
if(s.isEqual(tmpSession)) {
tmpSession.getClientInt().newGame(true);
tmpSession.getClientInt().getMessage("Answer-Bot", "Du hast das Lösungswort "+solution+" erraten!");
}
else {
tmpSession.getClientInt().newGame(false);
tmpSession.getClientInt().getMessage("Answer-Bot",s.getName()+ " hat das Lösungswort "+solution+" erraten!");
}
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
this.reset();
}
if(solution!=null&&lifes<=0) { //Startet neues Spiel, wenn Wort nicht gefunden wurde
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
if(tmpSession.getClientInt().getGamemaker())
tmpSession.getClientInt().newGame(true);
else
tmpSession.getClientInt().newGame(false);
tmpSession.getClientInt().getMessage("Answer-Bot","Das Lösungswort "+solution+" wurde nicht erraten!");
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
this.reset();
}
}
}
/**
* wird über die Session vom Spielmacher ausgeführt, um das Lösung festzulegen
* @param solution
* @param session
*/
public void sendSolution(String solution, Session session) {
this.solution=solution.toUpperCase();
for (int i=0; i<solution.length();i++) {
this.tmpSolution+="_ ";
}
Session tmpSession;
for(int j=0; j < this.sessionList.size(); j++) {
tmpSession = (Session)this.sessionList.get(j);
try {
tmpSession.getClientInt().getMessage("Answer-Bot", "Das Lösungswort steht fest, Los Gehts!");
} catch(RemoteException e) {
Session tmp2Session;
System.out.println(tmpSession.getName()+" ist unerreichbar und wird entfernt...");
for(int i=0; i<sessionList.size();i++) {
tmp2Session=(Session)this.sessionList.get(i);
if(tmp2Session.isEqual(tmpSession)) {
sessionList.remove(i);
}
}
}
}
this.showInformation();
}
/**
* Erstellt die neue Session mit Nutzernamen
*/
public SessionInterface makeSession(String name, ClientInterface clientInt) throws RemoteException {
System.out.println(name +" ist der Sitzung beigetreten.");
SessionInterface sessionInt = new Session(this, name, this.sessionList.size()+1,clientInt);
this.sessionList.add(sessionInt);
return sessionInt;
}
/**
* Setzt nach einem Spiel alles zurück
*/
private void reset() {
solution=null;
tmpSolution="";
lifes=12;
}
/**
* Prüft, ob die temporäre Lösung gefüllt ist
* @return
*/
public boolean isTmpSolutionFilled() {
boolean filled=true;
for(int o=0; o<tmpSolution.length();o++) {
if(tmpSolution.charAt(o)=='_') //Da "_" durch Buchstaben ersetzt werden, dürfen keine "_" vorhanden sein
filled=false;
}
return filled;
}
/**
* Gibt Leben und temporäre Lösung weiter zur Anzeige auf der RunClient Oberfläche
*/
public void showInformation() {
for(int j=0; j < this.sessionList.size(); j++) {
Session tmpSession = (Session)this.sessionList.get(j);
try {
tmpSession.getClientInt().showTmpSolution(" "+tmpSolution+" ; "+ "Leben: "+lifes);
} catch(Exception ex) {
System.out.println(ex.getMessage());
}
}
}
} |
package states;
import java.util.Stack;
import shape.Shape;
public class Different implements StackState {
PlayerStack stack;
public Different(PlayerStack stack) {
this.stack=stack;
}
@Override
public Stack insert(Shape shape) {
stack.stack.push(shape);
return stack.stack;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.