text
stringlengths 10
2.72M
|
|---|
package array;
import java.util.Scanner;
public class Largeno2 {
public static void main(String[] args)
{
Scanner s=new Scanner (System.in);
double n1, n2,n3;
System.out.println("Enter Number1:");
n1=s.nextDouble();
System.out.println("Enter Number2:");
n2=s.nextDouble();
System.out.println("Enter Number3");
n3=s.nextDouble();
s.close();
if(n1 >= n2) {
if(n1 >= n3)
System.out.println(n1 + " is the largest number.");
else
System.out.println(n3 + " is the largest number.");
} else {
if(n2 >= n3)
System.out.println(n2 + " is the largest number.");
else
System.out.println(n3 + " is the largest number.");
}
}
}
|
package com.company.model;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import javax.persistence.*;
import java.util.Date;
import java.util.Set;
@Entity
@Getter
@Setter
@NoArgsConstructor
@Table()
public class Manufacturer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
@Column
private String name;
@Column
private Date startDate;
@OneToMany(mappedBy = "manufacturer", fetch = FetchType.EAGER)
private Set<Product> products;
@Override
public String toString() {
return "Manufacturer{" +
"id=" + id +
", name='" + name + '\'' +
", startDate=" + startDate +
'}';
}
}
|
package myshop.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import myshop.mapper.ShoppingCartMapper;
import myshop.model.ShoppingCartItem;
import myshop.service.ShoppingCartService;
@Service
public class ShoppingCartServiceImpl implements ShoppingCartService {
private ShoppingCartMapper shoppingCartMapper;
@Autowired
public ShoppingCartServiceImpl(ShoppingCartMapper shoppingCartMapper) {
this.shoppingCartMapper = shoppingCartMapper;
}
@Override
public void addToCart(Long userId, Long cellphoneId, int amount) {
int ddd =shoppingCartMapper.itemExists(userId, cellphoneId);
if (shoppingCartMapper.itemExists(userId, cellphoneId) > 0) {
shoppingCartMapper.incItemAmount(userId, cellphoneId, amount);
} else {
shoppingCartMapper.createItem(userId, cellphoneId, amount);
}
}
@Override
public List<ShoppingCartItem> findAllItems(Long userId) {
return shoppingCartMapper.findAllItems(userId);
}
@Override
public void removeItem(Long userId, Long cellphoneId) {
shoppingCartMapper.removeItem(userId,cellphoneId);
}
}
|
package 表栈队列;
public class Hello{
public static void main(String[] args){
Cat cat = new Cat();
cat.name = "tom";
cat.age = 20;
System.out.println("name:" + cat.name + ", age:" + cat.age);
}
private static class Cat{
String name;
int age;
}
}
|
package com.esum.framework.jdbc.handler;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
public class YNBooleanTypeHandler extends BaseTypeHandler<Boolean> {
private boolean getYN(String value){
if(StringUtils.isEmpty(value))
return false;
return value.equals("Y");
}
@Override
public void setNonNullParameter(PreparedStatement ps, int i,
Boolean parameter, JdbcType jdbcType) throws SQLException {
String value = parameter.booleanValue()?"Y":"N";
ps.setString(i, value);
}
@Override
public Boolean getNullableResult(ResultSet rs, String columnName)
throws SQLException {
if (rs.wasNull()) {
return null;
} else {
return getYN(rs.getString(columnName));
}
}
@Override
public Boolean getNullableResult(CallableStatement cs, int columnIndex)
throws SQLException {
if (cs.wasNull()) {
return null;
} else {
return getYN(cs.getString(columnIndex));
}
}
@Override
public Boolean getNullableResult(ResultSet rs, int columnIndex)
throws SQLException {
if (rs.wasNull()) {
return null;
} else {
return getYN(rs.getString(columnIndex));
}
}
}
|
package com.ismailsozen.bilgilerenteresan;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
import java.util.List;
public class SQliteHelper extends SQLiteOpenHelper {
private static final int database_VERSION=1;
private static final String database_NAME="bilgiDb";
private static final String table_Bilgi="bilgiler";
private static final String bilgi_id="id";
private static final String bilgi_yazi="yazi";
private static final String create_table_bilgi="CREATE TABLE "+table_Bilgi+" ("+bilgi_id+" INTEGER PRIMARY KEY AUTOINCREMENT, "+bilgi_yazi+" TEXT )";
public SQliteHelper(Context context) {
super(context, database_NAME, null, database_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(create_table_bilgi);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS "+table_Bilgi);
this.onCreate(db);
}
public void BilgiEkle(Bilgi bilgi)
{
SQLiteDatabase db=this.getWritableDatabase();
ContentValues degerler=new ContentValues();
degerler.put(bilgi_yazi,bilgi.getBilgi_yazi());
db.insert(table_Bilgi,null,degerler);
db.close();
}
public List<Bilgi> BilgiGetir(){
Bilgi bilgi=null;
List<Bilgi> bilgiler=new ArrayList<>();
String query="SELECT * FROM "+table_Bilgi;
SQLiteDatabase db=this.getReadableDatabase();
Cursor cursor=db.rawQuery(query,null);
if (cursor.moveToFirst()){
do {
bilgi=new Bilgi();
bilgi.setBilgi_id(Integer.parseInt(cursor.getString(0)));
bilgi.setBilgi_yazi(cursor.getString(1));
bilgiler.add(bilgi);
}
while (cursor.moveToNext());
}
return bilgiler;
}
}
|
package com.cs.payment.devcode;
/**
* @author Hadi Movaghar
*/
public class DCInvalidSessionException extends RuntimeException {
private static final long serialVersionUID = 1L;
private final String playerId;
private final String sessionId;
public static final String INVALID_SESSION = "Session %s is invalid.";
public DCInvalidSessionException(final String playerId, final String sessionId) {
super(String.format(INVALID_SESSION, sessionId));
this.sessionId = sessionId;
this.playerId = playerId;
}
public String getSessionId() {
return sessionId;
}
public String getPlayerId() {
return playerId;
}
}
|
/**
* This class is generated by jOOQ
*/
package schema.tables.records;
import java.sql.Timestamp;
import javax.annotation.Generated;
import org.jooq.Field;
import org.jooq.Record1;
import org.jooq.Record10;
import org.jooq.Row10;
import org.jooq.impl.UpdatableRecordImpl;
import schema.tables.AssessmentStaffworkflow;
/**
* This class is generated by jOOQ.
*/
@Generated(
value = {
"http://www.jooq.org",
"jOOQ version:3.8.4"
},
comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class AssessmentStaffworkflowRecord extends UpdatableRecordImpl<AssessmentStaffworkflowRecord> implements Record10<Integer, String, String, String, String, Timestamp, Timestamp, Timestamp, Timestamp, String> {
private static final long serialVersionUID = 2103581760;
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.id</code>.
*/
public void setId(Integer value) {
set(0, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.id</code>.
*/
public Integer getId() {
return (Integer) get(0);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.scorer_id</code>.
*/
public void setScorerId(String value) {
set(1, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.scorer_id</code>.
*/
public String getScorerId() {
return (String) get(1);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.course_id</code>.
*/
public void setCourseId(String value) {
set(2, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.course_id</code>.
*/
public String getCourseId() {
return (String) get(2);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.item_id</code>.
*/
public void setItemId(String value) {
set(3, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.item_id</code>.
*/
public String getItemId() {
return (String) get(3);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.submission_uuid</code>.
*/
public void setSubmissionUuid(String value) {
set(4, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.submission_uuid</code>.
*/
public String getSubmissionUuid() {
return (String) get(4);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.created_at</code>.
*/
public void setCreatedAt(Timestamp value) {
set(5, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.created_at</code>.
*/
public Timestamp getCreatedAt() {
return (Timestamp) get(5);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.grading_completed_at</code>.
*/
public void setGradingCompletedAt(Timestamp value) {
set(6, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.grading_completed_at</code>.
*/
public Timestamp getGradingCompletedAt() {
return (Timestamp) get(6);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.grading_started_at</code>.
*/
public void setGradingStartedAt(Timestamp value) {
set(7, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.grading_started_at</code>.
*/
public Timestamp getGradingStartedAt() {
return (Timestamp) get(7);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.cancelled_at</code>.
*/
public void setCancelledAt(Timestamp value) {
set(8, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.cancelled_at</code>.
*/
public Timestamp getCancelledAt() {
return (Timestamp) get(8);
}
/**
* Setter for <code>bitnami_edx.assessment_staffworkflow.assessment</code>.
*/
public void setAssessment(String value) {
set(9, value);
}
/**
* Getter for <code>bitnami_edx.assessment_staffworkflow.assessment</code>.
*/
public String getAssessment() {
return (String) get(9);
}
// -------------------------------------------------------------------------
// Primary key information
// -------------------------------------------------------------------------
/**
* {@inheritDoc}
*/
@Override
public Record1<Integer> key() {
return (Record1) super.key();
}
// -------------------------------------------------------------------------
// Record10 type implementation
// -------------------------------------------------------------------------
/**
* {@inheritDoc}
*/
@Override
public Row10<Integer, String, String, String, String, Timestamp, Timestamp, Timestamp, Timestamp, String> fieldsRow() {
return (Row10) super.fieldsRow();
}
/**
* {@inheritDoc}
*/
@Override
public Row10<Integer, String, String, String, String, Timestamp, Timestamp, Timestamp, Timestamp, String> valuesRow() {
return (Row10) super.valuesRow();
}
/**
* {@inheritDoc}
*/
@Override
public Field<Integer> field1() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.ID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field2() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.SCORER_ID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field3() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.COURSE_ID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field4() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.ITEM_ID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field5() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.SUBMISSION_UUID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<Timestamp> field6() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.CREATED_AT;
}
/**
* {@inheritDoc}
*/
@Override
public Field<Timestamp> field7() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.GRADING_COMPLETED_AT;
}
/**
* {@inheritDoc}
*/
@Override
public Field<Timestamp> field8() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.GRADING_STARTED_AT;
}
/**
* {@inheritDoc}
*/
@Override
public Field<Timestamp> field9() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.CANCELLED_AT;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field10() {
return AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW.ASSESSMENT;
}
/**
* {@inheritDoc}
*/
@Override
public Integer value1() {
return getId();
}
/**
* {@inheritDoc}
*/
@Override
public String value2() {
return getScorerId();
}
/**
* {@inheritDoc}
*/
@Override
public String value3() {
return getCourseId();
}
/**
* {@inheritDoc}
*/
@Override
public String value4() {
return getItemId();
}
/**
* {@inheritDoc}
*/
@Override
public String value5() {
return getSubmissionUuid();
}
/**
* {@inheritDoc}
*/
@Override
public Timestamp value6() {
return getCreatedAt();
}
/**
* {@inheritDoc}
*/
@Override
public Timestamp value7() {
return getGradingCompletedAt();
}
/**
* {@inheritDoc}
*/
@Override
public Timestamp value8() {
return getGradingStartedAt();
}
/**
* {@inheritDoc}
*/
@Override
public Timestamp value9() {
return getCancelledAt();
}
/**
* {@inheritDoc}
*/
@Override
public String value10() {
return getAssessment();
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value1(Integer value) {
setId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value2(String value) {
setScorerId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value3(String value) {
setCourseId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value4(String value) {
setItemId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value5(String value) {
setSubmissionUuid(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value6(Timestamp value) {
setCreatedAt(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value7(Timestamp value) {
setGradingCompletedAt(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value8(Timestamp value) {
setGradingStartedAt(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value9(Timestamp value) {
setCancelledAt(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord value10(String value) {
setAssessment(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentStaffworkflowRecord values(Integer value1, String value2, String value3, String value4, String value5, Timestamp value6, Timestamp value7, Timestamp value8, Timestamp value9, String value10) {
value1(value1);
value2(value2);
value3(value3);
value4(value4);
value5(value5);
value6(value6);
value7(value7);
value8(value8);
value9(value9);
value10(value10);
return this;
}
// -------------------------------------------------------------------------
// Constructors
// -------------------------------------------------------------------------
/**
* Create a detached AssessmentStaffworkflowRecord
*/
public AssessmentStaffworkflowRecord() {
super(AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW);
}
/**
* Create a detached, initialised AssessmentStaffworkflowRecord
*/
public AssessmentStaffworkflowRecord(Integer id, String scorerId, String courseId, String itemId, String submissionUuid, Timestamp createdAt, Timestamp gradingCompletedAt, Timestamp gradingStartedAt, Timestamp cancelledAt, String assessment) {
super(AssessmentStaffworkflow.ASSESSMENT_STAFFWORKFLOW);
set(0, id);
set(1, scorerId);
set(2, courseId);
set(3, itemId);
set(4, submissionUuid);
set(5, createdAt);
set(6, gradingCompletedAt);
set(7, gradingStartedAt);
set(8, cancelledAt);
set(9, assessment);
}
}
|
package com.daniel.controller;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.daniel.dao.AdminDao;
import com.daniel.model.Admin;
public class AdminController extends HttpServlet {
private static final long serialVersionUID = 1L;
private static String INSERT_OR_EDIT = "/admin.jsp";
private static String LIST_ADMIN = "/listAdmin.jsp";
private AdminDao dao;
public AdminController() {
super();
dao = new AdminDao();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String forward="";
String action = request.getParameter("action");
if (action.equalsIgnoreCase("delete")){
String username = request.getParameter("username");
dao.deleteAdmin(username);
forward = LIST_ADMIN;
request.setAttribute("admins", dao.getAllAdmin());
} else if (action.equalsIgnoreCase("edit")){
forward = INSERT_OR_EDIT;
String username = request.getParameter("username");
Admin admin = dao.getAdminByUN(username);
request.setAttribute("user", admin);
} else if (action.equalsIgnoreCase("listAdmin")){
forward = LIST_ADMIN;
request.setAttribute("admins", dao.getAllAdmin());
} else {
forward = INSERT_OR_EDIT;
}
RequestDispatcher view = request.getRequestDispatcher(forward);
view.forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Admin admin = new Admin();
admin.setPassword(request.getParameter("password"));
admin.setEmail(request.getParameter("email"));
String username = request.getParameter("username");
if(username == null || username.isEmpty())
{
dao.addAdmin(admin);
}
else
{
admin.setUsername(username);
dao.updateAdmin(admin);
}
RequestDispatcher view = request.getRequestDispatcher(LIST_ADMIN);
request.setAttribute("users", dao.getAllAdmin());
view.forward(request, response);
}
}
|
package secondfactor.util;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
public class GenerateOTPUtil {
public static String generateOTP() {
try {
SecureRandom secureRandom = SecureRandom.getInstanceStrong();
String OTP = String.valueOf(secureRandom.ints(10_000, 100_000)
.findFirst().getAsInt());
return OTP;
} catch (NoSuchAlgorithmException e) {
SecureRandom secureRandom = new SecureRandom();
int randomOTP = secureRandom.ints(10_000, 100_000)
.findFirst().getAsInt();
return String.valueOf(randomOTP);
}
}
}
|
package com.thomasdedinsky.fydp.fydpweb.auth;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class EmailService {
//private final JavaMailSender javaMailSender;
public EmailService(/*JavaMailSender javaMailSender*/) {
super();
//this.javaMailSender = javaMailSender;
}
@Async
public void sendEmail(SimpleMailMessage email) {
//javaMailSender.send(email);
}
}
|
package com.example.authexample;
public class Constants {
public final static String SERVER_URL = "http://10.0.2.2:3000/";
// public final static String SERVER_URL = "http://androidappserver1.herokuapp.com/";
}
|
//
// Diese Datei wurde mit der JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.6 generiert
// Siehe <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Änderungen an dieser Datei gehen bei einer Neukompilierung des Quellschemas verloren.
// Generiert: 2014.09.03 um 04:35:53 PM CEST
//
package de.varylab.conformallab.data.types;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java-Klasse für Moebius complex type.
*
* <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist.
*
* <pre>
* <complexType name="Moebius">
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <attribute name="a" use="required" type="{http://www.w3.org/2001/XMLSchema}double" />
* <attribute name="b" use="required" type="{http://www.w3.org/2001/XMLSchema}double" />
* <attribute name="c" use="required" type="{http://www.w3.org/2001/XMLSchema}double" />
* <attribute name="d" use="required" type="{http://www.w3.org/2001/XMLSchema}double" />
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Moebius")
public class Moebius {
@XmlAttribute(name = "a", required = true)
protected double a;
@XmlAttribute(name = "b", required = true)
protected double b;
@XmlAttribute(name = "c", required = true)
protected double c;
@XmlAttribute(name = "d", required = true)
protected double d;
/**
* Ruft den Wert der a-Eigenschaft ab.
*
*/
public double getA() {
return a;
}
/**
* Legt den Wert der a-Eigenschaft fest.
*
*/
public void setA(double value) {
this.a = value;
}
/**
* Ruft den Wert der b-Eigenschaft ab.
*
*/
public double getB() {
return b;
}
/**
* Legt den Wert der b-Eigenschaft fest.
*
*/
public void setB(double value) {
this.b = value;
}
/**
* Ruft den Wert der c-Eigenschaft ab.
*
*/
public double getC() {
return c;
}
/**
* Legt den Wert der c-Eigenschaft fest.
*
*/
public void setC(double value) {
this.c = value;
}
/**
* Ruft den Wert der d-Eigenschaft ab.
*
*/
public double getD() {
return d;
}
/**
* Legt den Wert der d-Eigenschaft fest.
*
*/
public void setD(double value) {
this.d = value;
}
}
|
package com.taim.backendservice.service.staff;
import com.taim.backendservice.model.Staff;
import com.taim.backendservice.service.IBaseService;
public interface IStaffService extends IBaseService<Staff> {
}
|
package com.twoblueonebrown;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Lambert implements ILambert {
private List<Double> W0;
public double calcula(double x){
if(Math.abs(x)<(1/Math.exp(1))) {
double inf = Double.POSITIVE_INFINITY;
W0 = new ArrayList<>();
double a;
double b;
double xToThei;
for (int i = 1; i < inf; i++) {
// FORMAT: (a/b) * xToThei
a = Math.pow((-i), (i - 1));
b = Util.fatorial(i);
xToThei = Math.pow(x, i);
W0.add((a / b) * xToThei);
}
return Util.somatorio(1, ((int) inf),W0);
}
throw new IllegalArgumentException();
}
public Iterator returnIterator(){
if(W0!=null){return W0.iterator();}
throw new IllegalStateException("NO FUNCTION ITERATOR TO RETURN\nPROBABLY BECAUSE THERE IS NO HISTORY YET");
}
}
|
package test;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import com.blog.util.MD5Coder;
public class TestMD5 {
@Before
public void setUp() throws Exception {
}
@Test
public void test() {
String value="a1101971076";
String va= MD5Coder.encodeMD5Hex(value);
String value2=MD5Coder.encodeMD5Hex(value);
System.out.println(va);
Assert.assertEquals(va, "55b185e60f194dd2e2b87c67a541fb5c");
}
}
|
/*
* Класс: org.sheart.mpanzer.game.Model
* Описание:
* Класс предназначен для парсинга, хранения и отрисовки моделей в формате
* Wavefront OBJ.
* ____________________________________________________________________________
* Проект "Mission „Panzer“" лицензирован под BSD-3 License, ознакомиться с ко-
* торой можно в корне проекта, она изложена в файле "license.txt".
* Русскоязычная адаптация также находится в корне, в файле "license_rus.txt",
* и использует кодировку UTF-8.
* Разработчиком проекта является Yew_Mentzaki. Список всех контрибьюторов мож-
* но увидеть в корне проекта, в файле "contributors.txt".
*/
package org.sheart.mpanzer.game;
import java.io.File;
import java.io.FileNotFoundException;
import static java.lang.Math.atan2;
import java.util.ArrayList;
import java.util.Scanner;
import static org.lwjgl.opengl.GL11.*;
import org.lwjgl.util.vector.Vector3f;
import org.newdawn.slick.opengl.Texture;
import org.sheart.mpanzer.game.Camera;
/**
*
* @author yew_mentzaki
*/
public class Model {
private static Texture triangle, quad;
private static Texture triangleSmall, quadSmall;
public static void load() {
//Подгрузка крупных и мелких текстур:
triangle = Textures.texture("units/plate_triangle.png");
quad = Textures.texture("units/plate_quad.png");
triangleSmall = Textures.texture("units/plate_triangle_small.png");
quadSmall = Textures.texture("units/plate_quad_small.png");
//Отключение интерполяции:
triangle.setTextureFilter(GL_NEAREST);
quad.setTextureFilter(GL_NEAREST);
triangleSmall.setTextureFilter(GL_NEAREST);
quadSmall.setTextureFilter(GL_NEAREST);
}
private class Polygon {
Vector3f[] v;
public Polygon(Vector3f[] v) {
this.v = v;
}
public void render(boolean quality) {
//Отрисовка треугольного полигона:
if (v.length == 3) {
(quality?triangle:triangleSmall).bind();
glBegin(GL_TRIANGLES);
{
glTexCoord2d(0, 1);
glNormal3f(v[0].x, v[0].y, v[0].z);
glVertex3f(v[0].x, v[0].y, v[0].z);
glTexCoord2d(0.5, 0);
glNormal3f(v[1].x, v[1].y, v[1].z);
glVertex3f(v[1].x, v[1].y, v[1].z);
glTexCoord2d(1, 1);
glNormal3f(v[2].x, v[2].y, v[2].z);
glVertex3f(v[2].x, v[2].y, v[2].z);
}
glEnd();
}
//Отрисовка четырёхугольного полигона:
if (v.length == 4) {
(quality?quad:quadSmall).bind();
glBegin(GL_QUADS);
{
glTexCoord2d(0, 0);
glNormal3f(v[0].x, v[0].y, v[0].z);
glVertex3f(v[0].x, v[0].y, v[0].z);
glTexCoord2d(1, 0);
glNormal3f(v[1].x, v[1].y, v[1].z);
glVertex3f(v[1].x, v[1].y, v[1].z);
glTexCoord2d(1, 1);
glNormal3f(v[2].x, v[2].y, v[2].z);
glVertex3f(v[2].x, v[2].y, v[2].z);
glTexCoord2d(0, 1);
glNormal3f(v[3].x, v[3].y, v[3].z);
glVertex3f(v[3].x, v[3].y, v[3].z);
}
glEnd();
}
}
}
String name;
private float f(String line) {
return Float.parseFloat(line);
}
private int i(String line) {
return Integer.parseInt(line);
}
private Polygon[] polygons;
public Model(String name, File file) throws FileNotFoundException {
this.name = name;
ArrayList<Vector3f> v = new ArrayList<Vector3f>();
ArrayList<Polygon> p = new ArrayList<Model.Polygon>();
Scanner s = new Scanner(file);
//Построчный парсинг файла в формате Wavefront OBJ:
while (s.hasNextLine()) {
String l = s.nextLine().trim();
String a[] = l.split(" ");
//Если строка начинается с v, записывает её как вершину с тремя ко-
//ординатами:
if (l.charAt(0) == 'v') {
v.add(new Vector3f(f(a[1]), -f(a[3]), f(a[2])*1.5f));
}
//Если строка начинается с f, записывает её как полигон, добавив но-
//мера всех вершин фигуры:
if (l.charAt(0) == 'f') {
Vector3f[] vs = new Vector3f[a.length - 1];
for (int i = 0; i < a.length - 1; i++) {
vs[i] = v.get(i(a[i + 1]) - 1);
}
p.add(new Polygon(vs));
}
}
//Перенос полигоны из списка в массив:
polygons = new Polygon[p.size()];
for (int i = 0; i < p.size(); i++) {
polygons[i] = p.get(i);
}
}
public Model(String name){
this.name = name;
this.polygons = null;
}
public void render(Camera camera, boolean highpoly) {
//Последовательная отрисовка всех полигонов:
if(polygons==null){
polygons = Models.model(name).polygons;
}
for (Polygon p : polygons) {
p.render(highpoly);
}
}
}
|
package org.example.codingtest.twoLevel;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
public class TruckPassingTheBridge {
public static void main(String[] args) {
int bridge_length = 2;
int weight = 10;
int[] truck_weights = {7,4,5,6};
// int[] truck_weights = {10,10,10,10,10,10,10,10,10,10};
int solution = otherSolution(bridge_length, weight, truck_weights);
System.out.println(solution);
}
public static int otherSolution(int bridge_length, int weight, int[] truck_weights){
int answer = 0;
Queue<Integer> ing_q = new LinkedList<>();
int sum_weigth = 0;
for(int t : truck_weights){
while (true){
// 다리에 트럭 진입
if (ing_q.isEmpty()){
ing_q.add(t);
sum_weigth += t;
answer++;
break;
// 트럭이 다리 끝까지 갔다면
} else if (ing_q.size() == bridge_length){
sum_weigth -= ing_q.poll();
} else {
// 후속 트럭이 다리에 진입할 수 없다면
if (sum_weigth + t > weight){
answer++; // 먼저 진입한 트럭 한칸 앞으로
ing_q.add(0); // 트럭이 없으니 0으로 채움
} else {
ing_q.add(t);
sum_weigth += t;
answer++;
break;
}
}
}
}
return answer + bridge_length;
}
public static int solution(int bridge_length, int weight, int[] truck_weights) {
int answer = 0;
int ori_weight = weight;
Queue<Integer> start_q = new LinkedBlockingQueue<>();
for (int tw : truck_weights)
start_q.add(tw);
while (!start_q.isEmpty()) {
// 혼자 건너야하는 트럭
Integer s = start_q.poll();
answer += bridge_length;
weight -= s;
// 같이 건널 수 있는 트럭
while (!start_q.isEmpty() && weight - start_q.peek() >= 0) {
Integer b = start_q.poll();
answer += 1;
weight -= b;
}
weight = ori_weight;
}
return answer + 1;
}
}
|
package net.lvcy.card.entity;
public interface CombinNine extends CombinCard{
}
|
/*
* Inicial.java
*
* Created on 18/05/2007, 04:30:43 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
package com.davivienda.utilidades.conversion;
import java.math.BigDecimal;
import java.util.Formatter;
/**
*
* @author jjvargas
*/
public class Inicial {
/** Creates a new instance of Inicial */
public Inicial() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
String resp = JSon.getJSonRespuesta(0, "xxx");
Long newl2 =new Long(755620);
BigDecimal newl =new BigDecimal(800008955.234);
resp=com.davivienda.utilidades.conversion.Numero.aMonedaDecimal(newl);
System.out.print(newl2.toString().substring(newl2.toString().length()-2));
}
}
|
package org.flowable.cloud.runtime.core;
/**
* @author chen.xing<br>
* @version 1.0<br>
* @Desc good study day day up
* @data 2019<br>
*/
public interface Constant {
String CLOUD_STAGE_BEAN_NAME = "cloudClassDelegateServiceTaskStages";
}
|
package kz.greetgo.file_storage.errors;
import kz.greetgo.file_storage.impl.TablePosition;
public class TableIsAbsent extends RuntimeException {
public final TablePosition tablePosition;
// @Override
// public synchronized Throwable fillInStackTrace() {
// return this;
// }
public TableIsAbsent(TablePosition tablePosition) {
this.tablePosition = tablePosition;
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.topica.vn.baitap_thaytrungnt9.JDBC;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
/**
*
* @author khong
*/
public class CallableStatementJDBC {
//Tạo kết nối đến database
private static Connection myConnection(String dbName, String user, String password){
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/"+dbName,user,password);
} catch (Exception e) {
e.printStackTrace();
}
return con;
}
//In ra kết quả câu truy vấn select *
private void PrintResult(ResultSet result){
try {
while(result.next()){
System.out.println(result.getInt(1) +"\t"+ result.getString(2)+"\t"+result.getString(3)+"\t"+result.getString(4));
}
} catch (Exception e) {
e.printStackTrace();
}
}
static CallableStatement cst=null;
private static ResultSet result = null;
public static void main(String[] args) throws SQLException, ClassNotFoundException{
CallableStatementJDBC jdbc = new CallableStatementJDBC();
Connection con = myConnection("testdb", "root", "12345");
if(con != null) System.out.println("Ket noi thanh cong toi database");
try {
Statement st = con.createStatement();
//Tạo một table trong db
//st.execute("Create table Student(ID INT NOT NULL AUTO_INCREMENT, NAME VARCHAR(50) NOT NULL, ADDRESS VARCHAR(50), AGE INT, PRIMARY KEY (ID));");
//Thêm dữ liệu vào table
for(int i = 0;i < 10; i++){
st.execute("INSERT INTO STUDENT(NAME, ADDRESS, AGE) VALUES ('NGUYEN VAN TOAN', 'HA TAY', 21)");
}
//Tạo produre lấy ra toàn bộ student
// st.execute("CREATE PROCEDURE GETALLSTUDENT ()\n" +
// "BEGIN\n" +
// "SELECT *FROM STUDENT;" +
// "END");
//Tạo produre lấy ra sinh viên theo id
// st.execute("CREATE PROCEDURE GETSTUDENTBYID (IDSTUDENT INT)\n" +
// "BEGIN\n" +
// "SELECT *FROM STUDENT WHERE ID = IDSTUDENT;" +
// "END");
//Thực hiện các produre bằng CallableStatenment
cst = con.prepareCall("{CALL GETALLSTUDENT()}");
result = cst.executeQuery();
jdbc.PrintResult(result);
cst = con.prepareCall("{CALL GETSTUDENTBYID(?)}");
cst.setInt(1,new Scanner(System.in).nextInt());
result = cst.executeQuery();
jdbc.PrintResult(result);
//Ngắt kết nối tới db sau khi sử dụng xong
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
package com.jrz.bettingsite.player;
import com.jrz.bettingsite.team.Team;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.junit.Assert.*;
@RunWith(SpringJUnit4ClassRunner.class)
@WebMvcTest(value = PlayerController.class, secure = false)
public class PlayerControllerTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private PlayerService playerService;
@Test
public void getAllPlayers() throws Exception{
// before GET request
List<Player> players = new ArrayList<Player>(Arrays.asList(
new Player("Cristiano Ronaldo"),
new Player("Leonel Messi"),
new Player("Paul Pogba")
));
Mockito.when(playerService.findAll()).thenReturn(players);
// during
mockMvc.perform(MockMvcRequestBuilders.get("/players")
.contentType(MediaType.APPLICATION_JSON)
)
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.jsonPath("$[0].name",Matchers.is("Cristiano Ronaldo")))
.andExpect(MockMvcResultMatchers.jsonPath("$[1].name",Matchers.is("Leonel Messi")))
.andExpect(MockMvcResultMatchers.jsonPath("$[2].name",Matchers.is("Paul Pogba")));
// after
Mockito.verify(playerService).findAll();
}
@Test
public void findById() throws Exception{
// before GET request
Player player = new Player("Cristiano Ronaldo");
Mockito.when(playerService.findById(Mockito.anyLong())).thenReturn(Optional.ofNullable(player));
// during
mockMvc.perform(MockMvcRequestBuilders.get("/players/1")
.contentType(MediaType.APPLICATION_JSON)
)
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.jsonPath("$.name",Matchers.is("Cristiano Ronaldo")));
// after
Mockito.verify(playerService).findById(Mockito.anyLong());
}
@Test
public void savePlayer() throws Exception{
// before saveTeam POST
Player player = new Player("Cristiano Ronaldo");
String json = "{\n" +
" \"name\": \"Cristiano Ronaldo\"\n" +
"}";
Mockito.doNothing().when(playerService).savePlayer(Mockito.any(Player.class));
// during
mockMvc.perform(MockMvcRequestBuilders.post("/players")
.contentType(MediaType.APPLICATION_JSON)
.content(json)
)
.andExpect(MockMvcResultMatchers.status().isOk())
//.andExpect(MockMvcResultMatchers.status().isCreated())
.andDo(MockMvcResultHandlers.print());
// after
Mockito.verify(playerService).savePlayer(Mockito.any(Player.class));
}
}
|
package com.maliang.core.arithmetic.function;
import java.util.List;
import java.util.Map;
import com.maliang.core.arithmetic.ArithmeticExpression;
import com.maliang.core.exception.TianmaException;
import com.maliang.core.util.Utils;
public class Check {
@SuppressWarnings("unchecked")
public static Object execute(Function function,Map<String,Object> params){
List<Object> checkList = (List<Object>)function.executeExpression(params);
Object result = checkList.get(0);
if(result != null && result instanceof Boolean && (Boolean)result){
return true;
}
String errMsg = "Check error for "+function.getExpression();
if(checkList.size() >= 2){
errMsg = (String)checkList.get(1);
}
throw new TianmaException(errMsg);
}
public static Boolean isEmpty(Function function,Map<String,Object> params){
Object val = getValue(function,params);
return Utils.isEmpty(val);
}
public static Boolean isNull(Function function,Map<String,Object> params){
return getValue(function,params) == null;
}
public static Boolean notNull(Function function,Map<String,Object> params){
return getValue(function,params) != null;
}
private static Object getValue(Function fun,Map<String,Object> params){
if(fun.useKeyValue()){
return fun.getKeyValue();
}else {
return fun.executeExpression(params);
}
}
public static Boolean not(Function function,Map<String,Object> params){
Object val = getValue(function,params);
if(val instanceof Boolean){
return !((Boolean)val);
}
return false;
}
public static void main(String[] args) {
String s = "[user.pwd = password,'error message']";
// List checkList = (List)ArithmeticExpression.execute(s, null);
//
// System.out.println(checkList);
// System.out.println(checkList.get(0) instanceof Boolean);
s = "db.User.search()";
Object u = ArithmeticExpression.execute(s, null);
System.out.println(u);
}
}
|
/*
* @(#)Expert.java 1.0 06/24/99
*
*/
package org.google.code.netapps.chat.primitive;
/**
* Class for presenting expert (privileged participant).
*
* @version 1.0 06/24/99
* @author Alexander Shvets
*/
public class Expert extends PrivilegedParticipant {
/**
* Constructs expert with the specified name.
*
* @param name the name of expert
*/
public Expert(String name) {
super(name);
}
/**
* Get type.
*
* @return type
*/
public String getType() {
return ParticipantType.EXPERT;
}
}
|
/**
* Created by JohnBae on 10/17/15.
*/
public class EngineLogic {
public EngineLogic() {
}
public void k(){
}
}
|
package com.xzvfi.myheart.view;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.media.Image;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import com.facebook.AccessToken;
import com.xzvfi.myheart.R;
import com.xzvfi.myheart.Singleton;
import com.xzvfi.myheart.model.Heart;
import java.util.ArrayList;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
/**
* Created by xzvfi on 2016-07-13.
*/
public class StrangerListViewAdapter extends BaseAdapter {
private Context context;
private ArrayList<StrangerListItem> itemList = new ArrayList<StrangerListItem>();
public StrangerListViewAdapter() {
}
@Override
public int getCount() {
return itemList.size();
}
@Override
public Object getItem(int position) {
return itemList.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
final int pos = position;
this.context = parent.getContext();
if (convertView == null) {
LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
convertView = inflater.inflate(R.layout.stranger_list_item, parent, false);
}
ImageView faceImageView = (ImageView) convertView.findViewById(R.id.faceImageView);
TextView nameTextView = (TextView) convertView.findViewById(R.id.userNameTextView);
TextView descTextView = (TextView) convertView.findViewById(R.id.descriptionTextView);
TextView heartNumTextView = (TextView) convertView.findViewById(R.id.heartNumTextView);
ImageButton heartButton = (ImageButton) convertView.findViewById(R.id.heartButton);
final StrangerListItem listViewItem = itemList.get(position);
faceImageView.setImageDrawable(listViewItem.getFaceDrawable());
nameTextView.setText(listViewItem.getName());
descTextView.setText(listViewItem.getDescription());
heartNumTextView.setText(listViewItem.getHeartNum() + "");
heartButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Call<Heart> sendHeartCall = Singleton.getNetworkService().sendHeart(
new Heart(AccessToken.getCurrentAccessToken().getToken(),
listViewItem.getId())
);
sendHeartCall.enqueue(new Callback<Heart>() {
@Override
public void onResponse(Call<Heart> call, Response<Heart> response) {
if (response.isSuccessful()) {
Toast.makeText(context, listViewItem.getName() + " 님에게 하트 보내기 성공!", Toast.LENGTH_SHORT).show();
listViewItem.setHeartNum(listViewItem.getHeartNum() + 1);
StrangerListViewAdapter.this.notifyDataSetChanged();
} else {
Toast.makeText(context, "하트 보내기 실패 ㅠㅠ", Toast.LENGTH_SHORT).show();
}
}
@Override
public void onFailure(Call<Heart> call, Throwable t) {
t.printStackTrace();
Toast.makeText(context, "디비 접속 및 하트 보내기 실패 ㅠㅠ", Toast.LENGTH_SHORT).show();
}
});
}
});
return convertView;
}
public void addItem(String id, Drawable face, String name, String description, int heartNum) {
StrangerListItem item = new StrangerListItem();
item.setId(id);
item.setFaceDrawable(face);
item.setName(name);
item.setDescription(description);
item.setHeartNum(heartNum);
itemList.add(item);
}
}
|
package com.openfarmanager.android.filesystem.commands;
import com.openfarmanager.android.core.AbstractCommand;
import com.openfarmanager.android.filesystem.DropboxFile;
import com.openfarmanager.android.filesystem.actions.network.DropboxTask;
import com.openfarmanager.android.fragments.MainPanel;
/**
* @author Vlad Namashko
*/
public class DropboxCommand implements AbstractCommand {
private MainPanel mPanel;
private DropboxFile mFile;
private int mDropboxTask;
public DropboxCommand(MainPanel panel, DropboxFile file, int dropboxTask) {
mPanel = panel;
mFile = file;
mDropboxTask = dropboxTask;
}
@Override
public void execute(Object... args) {
try {
new DropboxTask(mPanel, mFile, mDropboxTask).execute();
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
package edu.kmi.primejavaC.JWC.View.Form;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Toolkit;
import javax.swing.JFrame;
import java.awt.BorderLayout;
import java.awt.Color;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import edu.kmi.primejavaC.JWC.Controller.FrontController;
import edu.kmi.primejavaC.JWC.Controller.Event.LoginEvent;
import java.awt.GridLayout;
import javax.swing.JPanel;
import javax.swing.JFormattedTextField;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
import javax.swing.JButton;
import javax.swing.ImageIcon;
import java.awt.Font;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class Login_Form extends Parent_Form{
private JTextField txtId;
private JPasswordField txtPw;
/**
* Create the application.
*/
public Login_Form(FrontController control) {
super(1024, 768, control);
setBackground(new Color(255, 255, 255));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("Login");
//------------컴포넌트 구성------------------
getContentPane().setLayout(null);
txtId = new JTextField();
txtId.setFont(new Font("맑은 고딕", Font.PLAIN, 17));
txtId.setBounds(400, 412, 197, 43);
getContentPane().add(txtId);
txtId.setColumns(20);
txtPw = new JPasswordField();
txtPw.setFont(new Font("맑은 고딕", Font.PLAIN, 17));
txtPw.setBounds(400, 482, 197, 43);
getContentPane().add(txtPw);
JButton btnLogin = new JButton("Login");
btnLogin.setFont(new Font("맑은 고딕", Font.BOLD, 18));
btnLogin.setBounds(650, 412, 112, 113);
getContentPane().add(btnLogin);
JLabel lblId = new JLabel("ID");
lblId.setFont(new Font("맑은 고딕", Font.BOLD, 18));
lblId.setHorizontalAlignment(SwingConstants.CENTER);
lblId.setBounds(242, 409, 112, 43);
getContentPane().add(lblId);
JLabel lblPassword = new JLabel("PASSWORD");
lblPassword.setHorizontalAlignment(SwingConstants.CENTER);
lblPassword.setFont(new Font("맑은 고딕", Font.BOLD, 18));
lblPassword.setBounds(242, 482, 112, 43);
getContentPane().add(lblPassword);
JLabel lblPlease = new JLabel("Please sign in your account");
lblPlease.setFont(new Font("맑은 고딕", Font.BOLD, 40));
lblPlease.setHorizontalAlignment(SwingConstants.CENTER);
lblPlease.setBounds(210, 162, 572, 155);
getContentPane().add(lblPlease);
JButton btnSignUp = new JButton("Sign Up");
btnSignUp.setFont(new Font("맑은 고딕", Font.BOLD, 18));
btnSignUp.setBounds(808, 639, 125, 43);
getContentPane().add(btnSignUp);
//--------------컴포넌트 구성 end--------------------------------
//-------------------이벤트 등록--------------------------------
btnLogin.addActionListener(new LoginEvent(this));
btnSignUp.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
SignUp_Form sign_up = new SignUp_Form(getControl());
}
});
//-------------------이벤트 등록 end-----------------------------
}
public String[] get_Account(){
String[] account = {txtId.getText(), new String(txtPw.getPassword(), 0, txtPw.getPassword().length)};
return account;
}
}
|
package kr.co.wisenut.editor.model;
public class Video {
private int recid;
private int vdoId;
private String vdoTitle;
private String vdoType;
private String language;
private String productionDate;
/*private String filePath;
private String vdoExt;*/
private int runtime;
/*private String vdoLClasCd1;
private String vdoSClasCd1;
private String vdoLClasCd2;
private String vdoSClasCd2;
private String vdoLClasCd3;
private String vdoSClasCd3;*/
private int scnCnt;
public int getRecid() {
return recid;
}
public void setRecid(int recid) {
this.recid = recid;
}
public int getVdoId() {
return vdoId;
}
public void setVdoId(int vdoId) {
this.vdoId = vdoId;
}
public String getVdoTitle() {
return vdoTitle;
}
public void setVdoTitle(String vdoTitle) {
this.vdoTitle = vdoTitle;
}
public String getVdoType() {
return vdoType;
}
public void setVdoType(String vdoType) {
this.vdoType = vdoType;
}
public String getLanguage() {
return language;
}
public void setLanguage(String language) {
this.language = language;
}
public String getProductionDate() {
return productionDate;
}
public void setProductionDate(String productionDate) {
this.productionDate = productionDate;
}
public int getRuntime() {
return runtime;
}
public void setRuntime(int runtime) {
this.runtime = runtime;
}
public int getScnCnt() {
return scnCnt;
}
public void setScnCnt(int scnCnt) {
this.scnCnt = scnCnt;
}
}
|
package com.lesports.albatross.entity.user;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
/**
*
* Created by zhouchenbin on 16/6/1.
*/
public class MomentMessageEntity {
@SerializedName("avatarUri")
@Expose
private String avatarUri;
@SerializedName("comments_time")
@Expose
private String commentsTime;
@SerializedName("message_content")
@Expose
private String messageContent;
@SerializedName("message_id")
@Expose
private String messageId;
@SerializedName("message_type")
@Expose
private String messageType;
@SerializedName("moment_content")
@Expose
private String momentContent;
@SerializedName("moment_id")
@Expose
private Integer momentId;
@SerializedName("moment_image")
@Expose
private String momentImage;
@SerializedName("nickName")
@Expose
private String nickName;
@SerializedName("user_id")
@Expose
private String userId;
@SerializedName("uuid")
@Expose
private String uuid;
/**
*
* @return
* The avatarUri
*/
public String getAvatarUri() {
return avatarUri;
}
/**
*
* @param avatarUri
* The avatarUri
*/
public void setAvatarUri(String avatarUri) {
this.avatarUri = avatarUri;
}
/**
*
* @return
* The commentsTime
*/
public String getCommentsTime() {
return commentsTime;
}
/**
*
* @param commentsTime
* The comments_time
*/
public void setCommentsTime(String commentsTime) {
this.commentsTime = commentsTime;
}
/**
*
* @return
* The messageContent
*/
public String getMessageContent() {
return messageContent;
}
/**
*
* @param messageContent
* The message_content
*/
public void setMessageContent(String messageContent) {
this.messageContent = messageContent;
}
/**
*
* @return
* The messageId
*/
public String getMessageId() {
return messageId;
}
/**
*
* @param messageId
* The message_id
*/
public void setMessageId(String messageId) {
this.messageId = messageId;
}
/**
*
* @return
* The messageType
*/
public String getMessageType() {
return messageType;
}
/**
*
* @param messageType
* The message_type
*/
public void setMessageType(String messageType) {
this.messageType = messageType;
}
/**
*
* @return
* The momentContent
*/
public String getMomentContent() {
return momentContent;
}
/**
*
* @param momentContent
* The moment_content
*/
public void setMomentContent(String momentContent) {
this.momentContent = momentContent;
}
/**
*
* @return
* The momentId
*/
public Integer getMomentId() {
return momentId;
}
/**
*
* @param momentId
* The moment_id
*/
public void setMomentId(Integer momentId) {
this.momentId = momentId;
}
/**
*
* @return
* The momentImage
*/
public String getMomentImage() {
return momentImage;
}
/**
*
* @param momentImage
* The moment_image
*/
public void setMomentImage(String momentImage) {
this.momentImage = momentImage;
}
/**
*
* @return
* The nickName
*/
public String getNickName() {
return nickName;
}
/**
*
* @param nickName
* The nickName
*/
public void setNickName(String nickName) {
this.nickName = nickName;
}
/**
*
* @return
* The userId
*/
public String getUserId() {
return userId;
}
/**
*
* @param userId
* The user_id
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
*
* @return
* The uuid
*/
public String getUuid() {
return uuid;
}
/**
*
* @param uuid
* The uuid
*/
public void setUuid(String uuid) {
this.uuid = uuid;
}
}
|
package it.unical.dimes.processmining.core;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
/**
*
* @author frank created on Mar 8, 2013 2:35:58 PM
*/
public class Node {
HashMap<TreeSet<Integer>, Integer> output = new HashMap<TreeSet<Integer>, Integer>();
HashMap<TreeSet<Integer>, Integer> input = new HashMap<TreeSet<Integer>, Integer>();
HashMap<TreeSet<Integer>, Integer> extendedOutput = new HashMap<TreeSet<Integer>, Integer>();
HashMap<TreeSet<Integer>, Integer> extendedInput = new HashMap<TreeSet<Integer>, Integer>();
public HashMap<TreeSet<Integer>, Integer> getExtendedOutput() {
return extendedOutput;
}
public void setExtendedOutput(HashMap<TreeSet<Integer>, Integer> extendedOutput) {
this.extendedOutput = extendedOutput;
}
public HashMap<TreeSet<Integer>, Integer> getExtendedInput() {
return extendedInput;
}
public void setExtendedInput(HashMap<TreeSet<Integer>, Integer> extendedInput) {
this.extendedInput = extendedInput;
}
public HashMap<TreeSet<Integer>, Integer> getOutput() {
return output;
}
public void setOutput(HashMap<TreeSet<Integer>, Integer> output) {
this.output = output;
}
public HashMap<TreeSet<Integer>, Integer> getInput() {
return input;
}
public void setJoin(HashMap<TreeSet<Integer>, Integer> input) {
this.input = input;
}
public static void main(String... args) {
Node n1 = new Node("Ciao", 1);
Node n2 = new Node("Ciao", 2);
Node n3 = new Node("prova", 1);
Map<Node, Integer> mappa = new HashMap<Node, Integer>();
mappa.put(n1, 1);
mappa.put(n2, 2);
mappa.put(n3, 3);
Node n4 = new Node("Ciao", 1);
Node n5 = new Node("f", 1);
if (mappa.containsKey(n4))
System.out.println("OK");
if (mappa.containsKey(n5))
System.out.println("NOK");
// System.out.println(n1.equals(n2));
// System.out.println(n1.equals(n3));
// System.out.println(n1.equals(n4));
}
private int inner_degree = 0;
private int outer_degree = 0;
private final int id_attivita;
private final String nome_attivita;
private boolean mark = false;
public Node(String nome_attivita, int id_attivita) {
super();
this.nome_attivita = nome_attivita;
this.id_attivita = id_attivita;
}
public void decr_Inner_degree() {
inner_degree--;
}
public void decr_Outer_degree() {
outer_degree--;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (id_attivita != other.id_attivita)
return false;
if (nome_attivita == null) {
if (other.nome_attivita != null)
return false;
} else if (!nome_attivita.equals(other.nome_attivita))
return false;
return true;
}
/**
* @return the id_attivita
*/
public int getID_attivita() {
return id_attivita;
}
public int getInner_degree() {
return inner_degree;
}
public String getNomeAttivita() {
return nome_attivita;
}
public int getOuter_degree() {
return outer_degree;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id_attivita;
result = prime * result + ((nome_attivita == null) ? 0 : nome_attivita.hashCode());
return result;
}
public void incr_Inner_degree() {
inner_degree++;
}
public void incr_Outer_degree() {
outer_degree++;
}
/**
* @return the mark
*/
public boolean isMarked() {
return mark;
}
public void setInner_degree(int inner_degree) {
this.inner_degree = inner_degree;
}
public void setOuter_degree(int outer_degree) {
this.outer_degree = outer_degree;
}
/**
* @param mark
* the mark to set
*/
public void setMark(boolean mark) {
this.mark = mark;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "[id " + id_attivita + "] [nome_attivita " + nome_attivita + "]";
}
}
|
package team21.pylonconstructor;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.EditText;
import android.widget.Toast;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
/**
* Created by ryanp on 2017-03-31.
*/
public class SocialSituationPickerFragment extends DialogFragment {
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
ElasticSearch elasticSearch = new ElasticSearch();
Profile profile = Controller.getInstance().getProfile();
final ArrayList<String> followingList = elasticSearch.getFollowing(profile.getUserName());
String[] followingArray = new String[followingList.size()];
followingArray = followingList.toArray(followingArray);
final ArrayList<String> selectedUserList = new ArrayList<>();
AlertDialog.Builder builder =
new AlertDialog.Builder(getActivity());
final String[] finalFollowingArray = followingArray;
builder.setTitle("Select users")
.setMultiChoiceItems(finalFollowingArray, null,
new DialogInterface.OnMultiChoiceClickListener() {
public void onClick(DialogInterface dialog, int item, boolean isChecked) {
if (isChecked) {
Log.i("DialogSelect", "Selected is: " + finalFollowingArray[item]);
selectedUserList.add(finalFollowingArray[item]);
}
else {
Log.i("DialogSelect", "Unselect is: " + finalFollowingArray[item]);
selectedUserList.remove(finalFollowingArray[item]);
}
}
});
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
UpdateMoodActivity act = (UpdateMoodActivity) getActivity();
act.setSocialSituationUsersList(selectedUserList);
} });
builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
Log.i("DialogSelect", "Cancelled!");
} });
return builder.create();
}
}
|
package com.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import com.test.base.Solution;
/**
* 36ms
* @author YLine
*
* 2018年12月12日 上午11:01:22
*/
public class SolutionA implements Solution
{
private static final int LENGTH = 10;
@Override
public List<String> findRepeatedDnaSequences(String s)
{
if (s.length() < LENGTH)
{
return new ArrayList<>();
}
List<String> result = new ArrayList<>();
int[] valueArray = value(s);
HashMap<Integer, Boolean> hashMap = new HashMap<>(); // 值 - 是否已添加过字符串
for (int i = 0; i < valueArray.length; i++)
{
if (hashMap.containsKey(valueArray[i]))
{
if (!hashMap.get(valueArray[i]))
{
result.add(s.substring(i, i + LENGTH));
hashMap.put(valueArray[i], true);
}
}
else
{
hashMap.put(valueArray[i], false);
}
}
return result;
}
/**
* 在前面的为低位，后面的为高位
* @param stack
* @return
*/
public int[] value(String stack)
{
int[] valueArray = new int[stack.length() - LENGTH + 1];
// 计算第一个Value
for (int i = 0; i < LENGTH; i++)
{
valueArray[0] += (charValue(stack.charAt(i)) << (2 * i));
}
// 依据首个，计算其他的Value
for (int i = 1; i < valueArray.length; i++)
{
valueArray[i] = (valueArray[i - 1] >> 2) + (charValue(stack.charAt(i + LENGTH - 1)) << 18);
}
return valueArray;
}
private int charValue(char ch)
{
switch (ch)
{
case 'A':
return 0;
case 'G':
return 1;
case 'T':
return 2;
case 'C':
return 3;
default:
return 0;
}
}
}
|
package org.vincent.event.threadpool;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author PengRong
* @package org.vincent.event.threadpool
* @ClassName AsyncConfig.java
* @date 2019/8/8 - 8:03
* @ProjectName JavaAopLearning
* @Description: 基于Spring 实现 线程池参数实现，将一个线程池实例作为一个bean
*/
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
/**
* 自定义线程工厂，
*/
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pengrong-AsyncConfig-" +
poolNumber.getAndIncrement() +
"-test-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
/** 设置异常处理器 处理未捕获异常 */
// t.setUncaughtExceptionHandler(new UEHLogger());
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
/**
* 构建一个线程池Bean
* @return
*/
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
threadPoolTaskExecutor.setCorePoolSize(10);
threadPoolTaskExecutor.setMaxPoolSize(50);
threadPoolTaskExecutor.setQueueCapacity(5);
threadPoolTaskExecutor.setKeepAliveSeconds(1);
threadPoolTaskExecutor.setBeanName("-ABcD-");
threadPoolTaskExecutor.setThreadFactory(new DefaultThreadFactory());
threadPoolTaskExecutor.setRejectedExecutionHandler((r, executor) -> System.out.println(executor.getActiveCount()));
/**
* 根据线程池参数设置 初始化一个 线程池实例
* */
threadPoolTaskExecutor.initialize();
return threadPoolTaskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return new AsyncUncaughtExceptionHandler() {
@Override
public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
System.out.println("出现异常啦~~~~~~， Method = "+method.getName()+" threadName = "+Thread.currentThread().getName());
System.out.println(throwable);
}
};
}
}
|
package sop.vo;
/**
* @Author: LCF
* @Date: 2020/1/9 12:37
* @Package: sop.vo
*/
public class SearchTemplateConditionVo {
private Integer fkItemMaster;
private String itemMasterType;
private Integer fkTemplate;
private String templateName;
private String engTemplateName;
public String getItemMasterType() {
return itemMasterType;
}
public void setItemMasterType(String itemMasterType) {
this.itemMasterType = itemMasterType;
}
public String getTemplateName() {
return templateName;
}
public void setTemplateName(String templateName) {
this.templateName = templateName;
}
public Integer getFkItemMaster() {
return fkItemMaster;
}
public void setFkItemMaster(Integer fkItemMaster) {
this.fkItemMaster = fkItemMaster;
}
public Integer getFkTemplate() {
return fkTemplate;
}
public void setFkTemplate(Integer fkTemplate) {
this.fkTemplate = fkTemplate;
}
public String getEngTemplateName() {
return engTemplateName;
}
public void setEngTemplateName(String engTemplateName) {
this.engTemplateName = engTemplateName;
}
}
|
package pro.likada.dao;
import pro.likada.model.Product;
import java.util.List;
/**
* Created by bumur on 14.02.2017.
*/
public interface ProductDAO {
Product findById(long id);
List<Product> getProductsByGroupIds(List<Long> groupsIds);
List<Product> getProductsByGroupId(Long groupId);
void save(Product product);
void deleteById(Long id);
List<Product> getAllProducts();
}
|
package com.testapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.PropertySource;
import org.springframework.scheduling.annotation.EnableScheduling;
@PropertySource(value = "classpath:META-INF/build-info.properties", ignoreResourceNotFound = true)
@SpringBootApplication
@EnableScheduling
public class KafkaApplication {
public static void main(String[] args) {
SpringApplication.run(KafkaApplication.class, args);
}
}
|
package com.github.life.lab.leisure.backend.gateway.application;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* LeisureBackendGatewayApplication
*
* @author weichao.li (liweichao0102@gmail.com)
* @date 2018/10/30
*/
@SpringBootApplication
@EnableFeignClients({
"com.github.life.lab.leisure.member.authorization.feign"
})
@EnableZuulProxy
public class LeisureBackendGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(LeisureBackendGatewayApplication.class, args);
}
}
|
package Exercise2;
import java.util.concurrent.CompletableFuture;
public class Q6 {
public static void main(String[] args) {
//if we have to hit multiple api by seperate thread
CompletableFuture.supplyAsync(()->5)
.thenCompose((x)->CompletableFuture.supplyAsync(()->x+3))
.thenAcceptAsync(System.out::println);
//or
CompletableFuture.supplyAsync(()->1).
thenCombine(CompletableFuture.supplyAsync(()->2), (a,b)-> a+b ).
thenAcceptAsync(System.out::println);
}
}
|
package reynoldstitko.gillian;
import java.io.Closeable;
/**
* Created by gillianreynolds-titko on 2/2/17.
*/
public interface Connection extends Closeable{
//Define the interface
String getIP(); //public modifier is redundant for interface methods
String getPort();
String getProtocol();
String connect();
void close();
}
|
package toolkit.wicket.pagerenderer;
import org.apache.wicket.Application;
import org.apache.wicket.Page;
import org.apache.wicket.core.request.handler.PageProvider;
import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
import org.apache.wicket.protocol.http.BufferedWebResponse;
import org.apache.wicket.request.Response;
import org.apache.wicket.request.cycle.RequestCycle;
import javax.enterprise.context.ApplicationScoped;
/**
* @author simetrias
*/
@ApplicationScoped
public class PageRenderer {
public String renderPage(final Page page) {
final PageProvider pageProvider = new PageProvider(page);
final RenderPageRequestHandler handler = new RenderPageRequestHandler(pageProvider, RenderPageRequestHandler.RedirectPolicy.NEVER_REDIRECT);
final org.apache.wicket.request.handler.render.PageRenderer pageRenderer = Application.get().getPageRendererProvider().get(handler);
RequestCycle requestCycle = RequestCycle.get();
final Response oldResponse = requestCycle.getResponse();
BufferedWebResponse tempResponse = new BufferedWebResponse(null);
try {
requestCycle.setResponse(tempResponse);
pageRenderer.respond(requestCycle);
} finally {
requestCycle.setResponse(oldResponse);
}
return tempResponse.getText().toString();
}
}
|
package miniProgram;
import miniProgram.lotto.Lotto;
public class RunLotto {
public static void main(String[] args) {
Lotto lotto = new Lotto();
lotto.randomSevenNumber();
long myMoney = 0;
long myCount = 0;
while(true) {
myMoney += 1000;
myCount++;
System.out.println("내 번호 뽑기");
lotto.randomSixNumber();
System.out.println(lotto.myNumber);
lotto.myNumber.removeAll(lotto.winningNumber);
if(lotto.myNumber.size() == 0) {
System.out.println("[1 등 당첨!!]");
System.out.println("미쳤군요! 당신은 총 "+myCount+"번 시도해 "+myMoney+"원을 썼습니다...");
System.out.println("로또 번호: "+lotto.winningNumber+" + ["+lotto.bonus+"]");
break;
}else if (lotto.myNumber.size() == 1 && lotto.myNumber.remove((Integer)lotto.bonus)) {
System.out.println("[2 등 당첨!!]");
System.out.println("미쳤군요! 당신은 총 "+myCount+"번 시도해 "+myMoney+"원을 썼습니다...");
System.out.println("로또 번호: "+lotto.winningNumber+" + ["+lotto.bonus+"]");
break;
}
}
}
}
|
package com.example.android.beatmymovies;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import java.util.ArrayList;
/**
* Created by Admin on 05-01-2016.
*/
public class TrailorListAdapter extends ArrayAdapter<Trailor> {
public TrailorListAdapter(Context context, int resource, ArrayList<Trailor> objects) {
super(context, resource,objects);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
Trailor trailorItem = getItem(position);
if (convertView == null) {
convertView = LayoutInflater.from(getContext()).inflate(
R.layout.trailor_item, parent, false);
}
TextView trailorName = (TextView) convertView.findViewById(R.id.list_trailor_text);
trailorName.setText(trailorItem.name);
return convertView;
}
}
|
/*
* 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 hfttugas;
/**
*
* @author ROG
*/
public class buku extends perpustakaan{
private String judul;
private String pengarang;
private String jenis;
private int halaman;
public buku(String judul, String pengarang, String jenis, int halaman) {
this.judul = judul;
this.pengarang = pengarang;
this.jenis = jenis;
this.halaman = halaman;
}
public buku(){
judul = "null";
pengarang = "null";
jenis = "null";
halaman = 0;
}
public int getHalaman() {
return halaman;
}
public void setHalaman(int halaman) {
this.halaman = halaman;
}
public String getJudul() {
return judul;
}
public void setJudul(String judul) {
this.judul = judul;
}
public String getPengarang() {
return pengarang;
}
public void setPengarang(String pengarang) {
this.pengarang = pengarang;
}
public String getJenis() {
return jenis;
}
public void setJenis(String jenis) {
this.jenis = jenis;
}
}
|
package ua.siemens.dbtool.model.entities;
import ua.siemens.dbtool.model.enums.ActivityType;
import ua.siemens.dbtool.model.enums.Status;
import javax.persistence.*;
import java.time.LocalDate;
/**
* The class is a representation of Activity Entity
*
* @author Perevoznyk Pavlo
* creation date 11 May 2017
* @version 1.0
*/
@Entity
@Table(name = "activities")
public class Activity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Enumerated(EnumType.STRING)
@Column(name = "activity_type")
private ActivityType activityType;
@Column(name = "ordinal_number")
private Integer ordinalNumber;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "executor_id")
private User executor;
@Column(name = "startDate")
private LocalDate startDate;
@Column(name = "endDate")
private LocalDate endDate;
@Column(name = "fact_hours")
private double factHours;
@ManyToOne
@JoinColumn(name = "profile_id")
private Profile profile;
@Column(name = "p_number")
private String pNumber;
@Column(name = "netzplan")
private String netzplan;
@Column(name = "vorgang")
private String vorgang;
// @Enumerated(EnumType.STRING)
// @Column(name = "status")
// private Status status;
@ManyToOne
@JoinColumn(name = "job_id")
private Job job;
@Column(name = "is_hidden")
private boolean isHidden;
@Column(name = "actual_start_date")
private LocalDate actualStartDate;
@Column(name = "actual_end_date")
private LocalDate actualEndDate;
public Activity() {
}
@Override
public String toString() {
return "[ id=" + id +
", type=" + activityType +
", executor=[" + executor.getId() + ", " + executor.getFullName() +
"], startDate=" + startDate +
", endDate=" + endDate +
", profile=[" + profile.getId() + ", " + profile.getName() +
"], pNumber=" + pNumber +
", netzplan=" + netzplan +
", vorgang=" + vorgang +
", jobId=" + job.getId() + " ]";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Activity activity = (Activity) o;
if (activityType != activity.activityType) return false;
if (executor != null ? !executor.equals(activity.executor) : activity.executor != null) return false;
if (startDate != null ? !startDate.equals(activity.startDate) : activity.startDate != null) return false;
if (endDate != null ? !endDate.equals(activity.endDate) : activity.endDate != null) return false;
if (profile != null ? !profile.equals(activity.profile) : activity.profile != null) return false;
if (pNumber != null ? !pNumber.equals(activity.pNumber) : activity.pNumber != null) return false;
if (netzplan != null ? !netzplan.equals(activity.netzplan) : activity.netzplan != null) return false;
if (vorgang != null ? !vorgang.equals(activity.vorgang) : activity.vorgang != null) return false;
return job != null ? job.equals(activity.job) : activity.job == null;
}
@Override
public int hashCode() {
int result = activityType != null ? activityType.hashCode() : 0;
result = 31 * result + (executor != null ? executor.hashCode() : 0);
result = 31 * result + (startDate != null ? startDate.hashCode() : 0);
result = 31 * result + (endDate != null ? endDate.hashCode() : 0);
result = 31 * result + (profile != null ? profile.hashCode() : 0);
result = 31 * result + (pNumber != null ? pNumber.hashCode() : 0);
result = 31 * result + (netzplan != null ? netzplan.hashCode() : 0);
result = 31 * result + (vorgang != null ? vorgang.hashCode() : 0);
result = 31 * result + (job != null ? job.hashCode() : 0);
return result;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public User getExecutor() {
return executor;
}
public void setExecutor(User executor) {
this.executor = executor;
}
public LocalDate getStartDate() {
return startDate;
}
public void setStartDate(LocalDate startDate) {
this.startDate = startDate;
}
public LocalDate getEndDate() {
return endDate;
}
public void setEndDate(LocalDate endDate) {
this.endDate = endDate;
}
public Status getStatus() {
LocalDate today = LocalDate.now();
if (this.factHours == 0) {
if (today.isAfter(this.endDate)) {
return Status.Dead;
}
return Status.Planned;
}
if (today.isAfter(this.endDate)) {
return Status.Closed;
}
return Status.In_progress;
}
// public void setStatus(Status status) {
// this.status = status;
// }
public ActivityType getActivityType() {
return activityType;
}
public void setActivityType(ActivityType activityType) {
this.activityType = activityType;
}
public double getFactHours() {
return factHours;
}
public void setFactHours(double factHours) {
this.factHours = factHours;
}
public Profile getProfile() {
return profile;
}
public void setProfile(Profile profile) {
this.profile = profile;
}
public String getpNumber() {
return pNumber;
}
public void setpNumber(String pNumber) {
this.pNumber = pNumber;
}
public String getNetzplan() {
return netzplan;
}
public void setNetzplan(String netzplan) {
this.netzplan = netzplan;
}
public String getVorgang() {
return vorgang;
}
public void setVorgang(String vorgang) {
this.vorgang = vorgang;
}
public boolean isHidden() {
return isHidden;
}
public void setHidden(boolean hidden) {
isHidden = hidden;
}
public Job getJob() {
return job;
}
public void setJob(Job job) {
this.job = job;
}
public LocalDate getActualStartDate() {
return actualStartDate;
}
public void setActualStartDate(LocalDate actualStartDate) {
this.actualStartDate = actualStartDate;
}
public LocalDate getActualEndDate() {
return actualEndDate;
}
public void setActualEndDate(LocalDate actualEndDate) {
this.actualEndDate = actualEndDate;
}
public Integer getOrdinalNumber() {
return ordinalNumber;
}
public void setOrdinalNumber(Integer ordinalNumber) {
this.ordinalNumber = ordinalNumber;
}
}
|
import java.util.*;
public class AnotherCandies
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int numTestCases = in.nextInt();
//loop through total test cases
for (int i = 0; i < numTestCases; i++)
{
in.nextLine();
//get number of children
long children = in.nextLong();
long totalCandies = 0;
for (long x = 0; x < children; x++)
{
totalCandies += in.nextLong();
}
//System.out.println("totalCandies: " + totalCandies);
if ((totalCandies % children) == 0)
{
System.out.println("YES");
}
else
{
System.out.println("NO");
}
}
}
}
|
package datamodel.huffman.tree.linked;
import java.util.PriorityQueue;
import datamodel.RGB;
import datamodel.huffman.tree.AbstractTreeFactory;
import datamodel.huffman.tree.Tree;
import datamodel.huffman.tree.TreeNode;
/**
* produces linked trees and treenodes
*
* @apiviz.uses datamodel.huffman.tree.linked.LinkedTree
* @apiviz.uses datamodel.huffman.tree.linked.LinkedTreeNode
*/
public class LinkedTreeFactory extends AbstractTreeFactory {
public Tree produceTree() {
return new LinkedTree(this);
}
public Tree produceTree(PriorityQueue<TreeNode> queue) {
return new LinkedTree(this, queue);
}
public TreeNode produceTreeNode() {
return new LinkedTreeNode();
}
public TreeNode produceTreeNode(RGB rgb, int value) {
return new LinkedTreeNode(rgb, value);
}
public TreeNode produceTreeNode(RGB rgb) {
return new LinkedTreeNode(rgb);
}
public TreeNode produceTreeNode(int Value) {
return new LinkedTreeNode(Value);
}
}
|
package lu.eminozandac.ondamondclinet.utils;
import com.google.android.gms.maps.model.LatLng;
import java.util.Calendar;
import java.util.Random;
public class MyMath {
public static double EPSILON = 0.00000000001;
public static final String UNIT_METER = "meter";
public static final String UNIT_FEET = "feet";
public static int getRandom(int start, int end) {
if (start > end) {
int temp = start;
start = end;
end = temp;
}
Calendar calendar = Calendar.getInstance();
int seed = Integer.parseInt(DateTimeUtils.dateToString(calendar.getTime(), "ssmmhh"));
Random random = new Random(seed);
return random.nextInt(end - start + 1) + start;
}
public static double EARTH_RADIUS = 6366198;
/*
* Distance between two location
*/
// public static double distanceBetween(double lat_a, double lon_a, double lat_b, double lon_b) {
// double pk = 180/3.14169;
//
// double a1 = lat_a / pk;
// double a2 = lon_a / pk;
// double b1 = lat_b / pk;
// double b2 = lon_b / pk;
//
// double t1 = Math.cos(a1)*Math.cos(a2)*Math.cos(b1)*Math.cos(b2);
// double t2 = Math.cos(a1)*Math.sin(a2)*Math.cos(b1)*Math.sin(b2);
// double t3 = Math.sin(a1)*Math.sin(b1);
// double tt = Math.acos(t1 + t2 + t3);
//
// return EARTH_RADIUS * tt;
// }
public static LatLng move(LatLng startLL, double toNorth, double toEast) {
double lonDiff = meterToLongitude(toEast, startLL.latitude);
double latDiff = meterToLatitude(toNorth);
return new LatLng(startLL.latitude + latDiff, startLL.longitude
+ lonDiff);
}
public static double meterToLongitude(double meterToEast, double latitude) {
double latArc = Math.toRadians(latitude);
double radius = Math.cos(latArc) * EARTH_RADIUS;
double rad = meterToEast / radius;
return Math.toDegrees(rad);
}
private static double meterToLatitude(double meterToNorth) {
double rad = meterToNorth / EARTH_RADIUS;
return Math.toDegrees(rad);
}
/*
* Unit convert
*/
public static double MILE = 1609; // 1mile : 1609m
public static double meterToMile(double meter) {
return (meter/MILE);
}
public static double kmToMile(double kilo) {
return (kilo*1000/MILE);
}
}
|
package pool;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntergerDemo {
//原子性操作
// static int i = 0;
static AtomicInteger ai=new AtomicInteger(0);
public static void main(String[] args) {
CountDownLatch cd1 = new CountDownLatch(2);
new Thread(new Add(cd1)).start();
new Thread(new Add(cd1)).start();
}
}
class Add implements Runnable {
public Add(CountDownLatch cd1) {
}
@Override
public void run() {
}
}
|
package org.notice.gui;
import java.awt.*;
import org.notice.gui.panels.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.notice.beans.CommonStuff;
import org.notice.graphs.Graphs;
public class MySkillsTabbedPane extends JTabbedPane implements ActionListener
{
private JPanel basePanel = null, skillsAdmin = null, logOff = null;
private MyProfile1 myProfile = null;
private SkillsSearch skillsSearch = null;
private Reports2 reports = null;
private JButton logoffButton = null;
private ColleagueProfile colleague;
private Colleague2 colleague2;
private Admin admin;
private Graphs graphs ;
public MySkillsTabbedPane(JPanel basePanel, CommonStuff commonStuff)
{
this.basePanel = basePanel;
myProfile = new MyProfile1(commonStuff );
// colleague = new ColleagueProfile(commonStuff);
colleague2 = new Colleague2(commonStuff);
admin = new Admin(commonStuff);
skillsSearch = new SkillsSearch(commonStuff);
graphs = new Graphs( commonStuff);
skillsAdmin = new JPanel();
reports = new Reports2(commonStuff);
logOff = new JPanel();
logoffButton = new JButton("Log Off");
logoffButton.addActionListener(this);
logOff.add(logoffButton);
this.addTab("My Profile", myProfile);
this.addTab("Colleague", colleague2);
this.addTab("Skills Search", skillsSearch);
this.addTab("Reports", reports);
this.addTab("Skill Administration", admin);
this.addTab("Graphs" , graphs);
addChangeListener(new ChangeListener() {
@Override
public void stateChanged(ChangeEvent e) {
// System.out.println("Tab: " + getSelectedIndex());
if( getSelectedIndex() == 1 ) {
colleague2.reload();
}
// if( getSelectedIndex() == 6 ) {
// graphs.reload();
// }
}
});
}
@Override
public void actionPerformed(ActionEvent ae)
{
Object source = ae.getSource();
if(source == logoffButton)
{
int option = JOptionPane.showConfirmDialog(this, "Are you sure you want to exit?");
if(option == JOptionPane.OK_OPTION)
{
System.exit(0);
}
return;
}
}
}
|
package loecraftpack.common.blocks;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.INetworkManager;
import net.minecraft.network.packet.Packet;
import net.minecraft.network.packet.Packet132TileEntityData;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class TileProtectionMonolith extends TileEntity
{
public int offsetX
, offsetZ
, width = 8
, length = 8
, offsetXInc = 0
, offsetZInc = 0
, widthInc = 0
, lengthInc = 0;
public List<String> Owners = new ArrayList<String>();
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
offsetX = nbt.getInteger("ox");
offsetZ = nbt.getInteger("oz");
width = nbt.getInteger("w");
length = nbt.getInteger("l");
setOwners(nbt.getString("owners"));
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("ox", offsetX);
nbt.setInteger("oz", offsetZ);
nbt.setInteger("w", width);
nbt.setInteger("l", length);
nbt.setString("owners", getOwners());
}
@Override
public Packet getDescriptionPacket()
{
NBTTagCompound nbt = new NBTTagCompound();
writeToNBT(nbt);
return new Packet132TileEntityData(this.xCoord, this.yCoord, this.zCoord, 0, nbt);
}
@Override
public void onDataPacket(INetworkManager net, Packet132TileEntityData packet)
{
readFromNBT(packet.customParam1);
}
@SideOnly(Side.CLIENT)
public double getMaxRenderDistanceSquared()
{
return 65536.0D;
}
@SideOnly(Side.CLIENT)
public AxisAlignedBB getRenderBoundingBox()
{
return INFINITE_EXTENT_AABB;
}
public boolean pointIsProtected(int x, int z)
{
return (x >= (xCoord+offsetX-Math.ceil(width/2)) && x < (xCoord+offsetX+Math.floor(width/2))) &&
(z >= (zCoord+offsetZ-Math.ceil(length/2)) && z < (zCoord+offsetZ+Math.floor(length/2)));
}
public String getOwners()
{
String owners = "";
for(int i = 0; i < Owners.size(); i++ )
owners += (i==0?"":"|")+Owners.get(i);
return owners;
}
public void setOwners(String owners)
{
if (owners.equals(""))
Owners = new ArrayList(0);
else if (owners.contains("|"))
Owners = new ArrayList(Arrays.asList(owners.split("\\|")));
else
Owners = new ArrayList(Arrays.asList(owners));
}
public boolean isOwner(String username)
{
return Owners.contains(username);
}
}
|
package com.springD.framework.shiro;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.apache.shiro.web.util.WebUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import com.octo.captcha.service.image.ImageCaptchaService;
import com.springD.framework.common.Constants;
import com.springD.framework.exception.CaptchaErrorException;
import com.springD.framework.exception.CaptchaRequiredException;
import com.springD.framework.utils.ResponseUtils;
import com.springD.framework.utils.StringUtils;
import com.springD.framework.utils.UserUtils;
/**
* @Description: 扩展登录拦截器
* @author Chenz
* @date Nov 13, 2014 1:09:18 PM
* @version V1.0
*/
public class SystemAuthenticationFilter extends FormAuthenticationFilter{
private Logger logger = LoggerFactory.getLogger(SystemAuthenticationFilter.class);
@Autowired
private ImageCaptchaService imageCaptchaService;
/**
* 返回URL
*/
public static final String RETURN_URL = "returnUrl";
private Cache<String, AtomicInteger> passwordRetryCache;
public SystemAuthenticationFilter(CacheManager cacheManager) {
passwordRetryCache = cacheManager.getCache("passwordRetryCache");
}
protected boolean executeLogin(ServletRequest request,ServletResponse response) throws Exception {
AuthenticationToken token = createToken(request, response);
if (token == null) {
String msg = "create AuthenticationToken error";
throw new IllegalStateException(msg);
}
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
String username = (String) token.getPrincipal();
boolean adminLogin=false;
//判断是否管理员登录
if (req.getRequestURI().startsWith(req.getContextPath() + Constants.ADMIN_PREFIX)){
adminLogin=true;
}
//验证码校验
if (isCaptchaRequired(username,req, res)) {
String captcha = request.getParameter(Constants.CAPTCHA_PARAM);
if (StringUtils.isNoneBlank(captcha)) {
if (!imageCaptchaService.validateResponseForID(req.getSession().getId(), captcha)) {
return onLoginFailure(token,adminLogin,new CaptchaErrorException(), request, response);
}
} else {
return onLoginFailure(token,adminLogin,new CaptchaRequiredException(),request, response);
}
}
// if(isDisabled(username)){
// return onLoginFailure(token,adminLogin,new DisabledException(),request, response);
// }
try {
Subject subject = getSubject(request, response);
subject.login(token);
return onLoginSuccess(token,adminLogin,subject, request, response);
} catch (AuthenticationException e) {
logger.info("", e);
return onLoginFailure(token,adminLogin, e, request, response);
}
}
public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
boolean isAllowed = isAccessAllowed(request, response, mappedValue);
//登录跳转
if (isAllowed && isLoginRequest(request, response)) {
try {
issueSuccessRedirect(request, response);
} catch (Exception e) {
logger.error("", e);
}
return false;
}
return isAllowed || onAccessDenied(request, response, mappedValue);
}
/**
* 登录成功后URL跳转设置
*/
protected void issueSuccessRedirect(ServletRequest request, ServletResponse response)
throws Exception {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
String successUrl = req.getParameter(RETURN_URL);
if (StringUtils.isBlank(successUrl)) {
if (req.getRequestURI().startsWith(req.getContextPath() + Constants.ADMIN_PREFIX)) {
// 后台直接返回首页
// successUrl = getAdminIndex();
// 清除SavedRequest
WebUtils.getAndClearSavedRequest(request);
successUrl = Constants.ADMIN_INDEX;
// WebUtils.issueRedirect(request, response, successUrl, null,true);
// return;
}
}
// WebUtils.redirectToSavedRequest(req, res, successUrl);
if(req.getHeader("accept").indexOf("application/json") > -1 || (req
.getHeader("X-Requested-With")!= null && req
.getHeader("X-Requested-With").indexOf("XMLHttpRequest") > -1)){
//处理Ajax登录
Map<String, Object> resultMap = new HashMap<String, Object>();
resultMap.put("success", true);
resultMap.put("successUrl", successUrl);
ResponseUtils.renderJson(res, resultMap);
return;
}else{
//普通请求
WebUtils.redirectToSavedRequest(req, res, successUrl);
}
}
/**
* 是否需要校验验证码
* @param username
* @param request
* @param response
* @return
*/
private boolean isCaptchaRequired(String username,HttpServletRequest request, HttpServletResponse response) {
// AtomicInteger retryCount = passwordRetryCache.get(username);
AtomicInteger retryCount = passwordRetryCache.get(request.getSession().getId());
String captcha = request.getParameter(Constants.CAPTCHA_PARAM);
// 如果输入了验证码，那么必须验证；如果没有输入验证码，则根据当前用户判断是否需要验证码。
if (!StringUtils.isBlank(captcha)|| (retryCount != null && retryCount.get() > Constants.LOGIN_TRY_TIME)) {
return true;
}
return false;
}
protected boolean isLoginRequest(ServletRequest req, ServletResponse resp) {
return pathsMatch(getLoginUrl(), req)
|| pathsMatch(Constants.ADMIN_LOGIN_URL, req);
}
/**
* 登录成功
*/
private boolean onLoginSuccess(AuthenticationToken token,boolean adminLogin,Subject subject,
ServletRequest request, ServletResponse response)
throws Exception {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
ShiroUser user = (ShiroUser) subject.getPrincipal();
//登陆成功后的一些日志操作
// CmsUser user = cmsUserMng.findByUsername(username);
// String ip = RequestUtils.getIpAddr(req);
// userMng.updateLoginInfo(user.getId(), ip);
// //管理登录
// if(adminLogin){
// cmsLogMng.loginSuccess(req, user);
// }
// 清除需要验证码cookie
// passwordRetryCache.remove(user.getName());
//为druid的session监控 添加当前登录用户的用户名
String name = UserUtils.getShiroUser().getName();
setAttribute(req, res, Constants.LOGIN_USERNAME,name);
passwordRetryCache.remove(req.getSession().getId());
return super.onLoginSuccess(token, subject, request, response);
}
private void setAttribute(HttpServletRequest request,
HttpServletResponse response, String name, String value) {
HttpSession session = request.getSession();
session.setAttribute(name, value);
}
/**
* 登录失败
*/
private boolean onLoginFailure(AuthenticationToken token,boolean adminLogin,AuthenticationException e, ServletRequest request,
ServletResponse response) {
// String username = (String) token.getPrincipal();
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
// AtomicInteger retryCount = passwordRetryCache.get(username);
AtomicInteger retryCount = passwordRetryCache.get(req.getSession().getId());
if(retryCount == null) {
retryCount = new AtomicInteger(0);
// passwordRetryCache.put(username, retryCount);
passwordRetryCache.put(req.getSession().getId(), retryCount);
}
retryCount.incrementAndGet();
//管理登录
// if(adminLogin){
// cmsLogMng.loginFailure(req,"username=" + username);
// }
//如果是Ajax请求
if(req.getHeader("accept").indexOf("application/json") > -1 || (req
.getHeader("X-Requested-With")!= null && req
.getHeader("X-Requested-With").indexOf("XMLHttpRequest") > -1)){
String exceptionName = e.getClass().getSimpleName();
Map<String, Object> resultMap = new HashMap<String, Object>();
resultMap.put("success", false);
resultMap.put("isCaptchaRequired",false);
if(retryCount.get() > Constants.LOGIN_TRY_TIME){
resultMap.put("isCaptchaRequired",true);
}
if("DisabledAccountException".equals(exceptionName)){
resultMap.put("message", "如果您是家长,请到<a href='http://www.aiwei365.com'>爱维宝贝官网</a>登陆/激活<br/>如果您是园长,请使用激活时使用的用户名登陆");
resultMap.put("type","username");
}
else if("UnknownAccountException".equals(exceptionName)){
resultMap.put("message", "您输入的账户名和密码不匹配，请重新输入");
resultMap.put("type","username");
}else if("IncorrectCredentialsException".equals(exceptionName)){
resultMap.put("message", "您输入的账户名和密码不匹配，请重新输入");
resultMap.put("type","password");
}else if("CaptchaErrorException".equals(exceptionName)){
resultMap.put("message", "验证码错误");
resultMap.put("type","captcha");
}else if("CaptchaRequiredException".equals(exceptionName)){
resultMap.put("message", "验证码不能为空");
resultMap.put("type","captcha");
}else if("LockedAccountException".equals(exceptionName)){
resultMap.put("message", "账号被锁定或未激活");
resultMap.put("type","system");
}else if("ExcessiveAttemptsException".equals(exceptionName)){
resultMap.put("message", "错误次数超过限制");
resultMap.put("type","system");
}else{
resultMap.put("message", "未知错误，请联系管理员");
resultMap.put("type","system");
}
ResponseUtils.renderJson(res, resultMap);
}
setFailureAttribute(request, e);
// return super.onLoginFailure(token, e, request, response);
return false;
}
}
|
package test;
public class Test1 {
public static void main(String[] args) {
int a=20;
String c="吃货";
System.out.println("吃货的世界我不懂");
int d =3;
System.out.println("aaa");
System.out.println("bbbb");
}
}
|
package network.topdown.application.http.protocol;
import org.apache.commons.lang3.StringUtils;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
public class HttpRequestUtil {
public static void writeRequest(Writer writer, HttpRequest request) throws IOException {
writeHeader(writer, request.getUrlLine());
for (Map.Entry<String, String> entry : request.getHeaders().entrySet()) {
writeHeader(writer, entry.getKey() + ":" + entry.getValue());
}
writer.write(HttpConstant.CRLF);
writer.flush();
}
private static void writeHeader(Writer writer, String header) throws IOException {
writer.write(header + HttpConstant.CRLF);
}
public static void write(OutputStream os, String line) throws IOException {
os.write((line + HttpConstant.CRLF).getBytes(StandardCharsets.UTF_8));
}
public static HttpRequest readRequest(Socket connectionSocket) throws IOException {
InputStreamReader ir = new InputStreamReader(connectionSocket.getInputStream(), StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(ir);
return HttpRequestUtil.parseRequest(br);
}
public static HttpRequest parseRequest(BufferedReader br) throws IOException {
boolean firstLine = true;
HttpRequest request = new HttpRequest();
Map<String, String> headers = new HashMap<>();
request.setHeaders(headers);
while (true) {
String line = br.readLine();
if (StringUtils.isBlank(line)) {
break;
}
if (firstLine) {
parseFirstLine(line, request);
firstLine = false;
} else {
parseHeader(line, headers);
}
}
return request;
}
private static void parseFirstLine(String line, HttpRequest request) {
String[] pieces = line.split(" ");
if (pieces.length < 3) {
return;
}
request.setMethod(pieces[0]);
request.setUrl(pieces[1]);
request.setHttpVersion(pieces[2]);
}
private static void parseHeader(String line, Map<String, String> headers) {
if (!line.contains(":")) {
return;
}
String[] pieces = line.split(":");
headers.put(pieces[0].trim(), pieces[1].trim());
}
}
|
package ec.com.comida.comunication;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ec.com.comida.bean.Menu;
import ec.com.comida.bean.MenuItem;
import ec.com.comida.serializer.MenuItemSerializer;
public class PedidoCliente {
private static PedidoCliente instance = null;
@JsonSerialize(using = MenuItemSerializer.class)
private List<MenuItem> menuItemList;
public static PedidoCliente getInstance() {
if (instance == null) {
instance = new PedidoCliente();
}
return instance;
}
public PedidoCliente() {
}
@JsonIgnore
public void sendJSONMessage(List<MenuItem> menuItemList)
throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
Menu bean = new Menu();
bean.setMenuItemList(menuItemList);
String jsonInString = mapper.writeValueAsString(bean);
String serverName = "127.0.0.1";
int port = 2040;
try {
System.out.println("Connecting to " + serverName + " on port "
+ port);
Socket client = new Socket(serverName, port);
System.out.println("Just connected to "
+ client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);
out.writeUTF(jsonInString);
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);
System.out.println("Server says " + in.readUTF());
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public List<MenuItem> getMenuItemList() {
return menuItemList;
}
public void setMenuItemList(List<MenuItem> menuItemList) {
this.menuItemList = menuItemList;
}
}
|
package com.suntf.pkm;
import cn.jpush.android.api.JPushInterface;
import android.app.Application;
import android.util.Log;
public class PKMApplication extends Application
{
@Override
public void onCreate()
{
Log.d("PKMApplication", "onCreate");
super.onCreate();
JPushInterface.setDebugMode(true); //设置开启日志,发布时请关闭日志
JPushInterface.init(this); // 初始化 JPush
}
}
|
package com.shopspecial.service;
import java.util.Collection;
import com.shopspecial.dao.ItemDAO;
import com.shopspecial.dao.ItemDAOImpl;
import com.shopspecial.pojo.Item;
public class ItemServiceImpl implements ItemService {
private ItemDAO dao = new ItemDAOImpl();
@Override
public void addNewItem(Item item) {
dao.addItem(item);
}
@Override
public Collection<Item> viewAllItems() {
return dao.viewAllItem();
}
@Override
public Collection<Item> cartItems() {
return dao.cartItem();
}
@Override
public void delete(Item item1) {
dao.delete(item1);
}
}
|
package bl.teambl;
public class TeamPlayer {
}
|
package com.lxl.util;
import com.lxl.BaseTest;
import org.apache.log4j.Logger;
import org.junit.Ignore;
import org.junit.Test;
/**
* Created by xiaolu on 15/5/5.
*/
public class Log extends BaseTest{
Logger logger = Logger.getLogger(Log.class);
@Test
@Ignore
public void log()
{
System.out.print("heere");
logger.info("ahdfadsf");
logger.debug("adfadf2");
logger.warn("2222");
}
}
|
package invadem;
import org.junit.Test;
import static org.junit.Assert.*;
public class InvaderTest {
@Test
public void testInvaderConstruction() {
Invader inv = new Invader();
assertNotNull(inv);
}
@Test
public void testInvaderFireProjectile() {
Invader inv = new Invader();
assertEquals(true,inv.isAlive());
}
@Test
public void testInvaderIsDead() {
Invader inv = new Invader();
inv.destroy = 1;
assertEquals(false,inv.isAlive());
}
}
|
package shu.ces.company.control;
import org.apache.tomcat.util.http.parser.Cookie;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import shu.ces.company.model.User;
import shu.ces.company.service.LoginService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
@Controller
public class Login {
@Autowired
LoginService loginService;
@GetMapping(value = "/login")
public String login(){
return "login";
}
@PostMapping(value="/login_verification")
public String login_verification(User user, HttpSession httpSession){
System.out.println(user.getEmail());
System.out.println(user.getUser_password());
String input_password=user.getUser_password();
user=loginService.queryPassword(user);
httpSession.setAttribute("currentUser",user);
if(!user.getUser_password().equals(input_password))
System.out.println("password is wrong");
User u=(User) httpSession.getAttribute("currentUser");
System.out.println(u.getUser_name());
return "redirect:robot";
}
}
|
/*
* 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 Main;
import Entity.data_mapel;
import Entity.data_pengajar;
import Error.data_mapelException;
import Error.data_nilaiException;
import Error.data_pengajarException;
import Error.data_siswaException;
import Service.data_mapelDao;
import Service.data_pengajarDao;
import View.MainViewPengajar;
import database.medikacomDatabase;
import java.sql.SQLException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
/**
*
* @author MY PC
*/
public class TugasBesar {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws SQLException, data_mapelException {
// TODO code application logic here
/*
dao1.deleteData_pengajar(876123);
*/
/*
data_pengajar data_pengajar = dao1.getData_pengajar(912247);
System.out.println("NAMA : " + data_pengajar.getNama());
*/
/*
List<data_pengajar> list = dao1.selectAllData_pengajar();
for (data_pengajar data_pengajar : list) {
System.out.println("IDPENGAJAR : " + data_pengajar.getIdpengajar());
System.out.println("NAMA : "+data_pengajar.getNama());
System.out.println("JK : "+data_pengajar.getJk());
System.out.println("----------------------------------------");
*/
/*
data_pengajar data_pengajar = dao1.getData_pengajar(876123);
data_pengajar.setNama("Rizki Wurtzbach");
data_pengajar.setJk("L");
dao1.updateData_pengajar(data_pengajar);
*/
}
}
|
package ball;
import ball.model.GenericBall;
/**
* Created by tinamt on 8/19/14.
*/
public interface Behavior {
public void update(GenericBall ball);
}
|
package crap_game;
public class BlueDie extends Die {
@Override
public Color dieColor() {
return Color.BLUE;
}
}
|
/**
* The MIT License (MIT)
*
* Copyright (c) 2018 Paul Campbell
*
* 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 net.kemitix.dependency.digraph.maven.plugin;
import net.kemitix.dependency.digraph.maven.plugin.digraph.EdgeElement;
import net.kemitix.dependency.digraph.maven.plugin.digraph.NodeElement;
import net.kemitix.dependency.digraph.maven.plugin.digraph.Subgraph;
import net.kemitix.node.Node;
import javax.annotation.concurrent.Immutable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* Generates a dot file dependency report as nested clusters.
*
* @author Paul Campbell (pcampbell@kemitix.net)
*/
@Immutable
class DotFileFormatNested extends AbstractDotFileFormat {
private static final String LINE = System.lineSeparator();
/**
* Constructor.
*
* @param base The root node
* @param nodePathGenerator The Node Path Generator
* @param graphFilter The Graph Filter
*/
DotFileFormatNested(
final Node<PackageData> base, final NodePathGenerator nodePathGenerator, final GraphFilter graphFilter
) {
super(base, nodePathGenerator, graphFilter);
}
private void addAnyLHead(
final Node<PackageData> headNode, final Node<PackageData> tailNode, final List<String> attributes
) {
// if head node has children, then add lhead attribute
if (headNode.getChildren()
.size() > 0 && !tailNode.isDescendantOf(headNode)) {
attributes.add(String.format("lhead=\"cluster%s\"", getClusterId(headNode)));
}
}
private void addAnyLTail(
final Node<PackageData> tailNode, final Node<PackageData> headNode, final List<String> attributes
) {
// if tail node has children, then add ltail attribute
if (tailNode.getChildren()
.size() > 0 && !headNode.isDescendantOf(tailNode)) {
attributes.add(String.format("ltail=\"cluster%s\"", getClusterId(tailNode)));
}
}
private String buildAttributeTag(final List<String> attributes) {
String attributeTag = "";
if (attributes.size() > 0) {
attributeTag = String.format(
"[%s]", attributes.stream()
.collect(Collectors.joining(",")));
}
return attributeTag;
}
@Override
public String render(final Subgraph subgraph) {
final String label = quoted(subgraph.getLabel());
final String id = quoted(subgraph.getId());
return String.format(
"subgraph %s{" + LINE + "label=%s" + LINE + "%s[label=\"\",style=\"invis\",width=0]" + LINE + "%s"
+ LINE + "}", quoted("cluster" + subgraph.getId()), label, id, renderElements(subgraph.getElements()));
}
@Override
public String render(
final EdgeElement edgeElement
) {
List<String> attributes = new ArrayList<>();
final Node<PackageData> tailNode = edgeElement.getTail()
.getPackageDataNode();
final Node<PackageData> headNode = edgeElement.getHead()
.getPackageDataNode();
addAnyLTail(tailNode, headNode, attributes);
addAnyLHead(headNode, tailNode, attributes);
String attributeTag = buildAttributeTag(attributes);
return String.format("%s->%s%s", quoted(getNodeId(tailNode)), quoted(getNodeId(headNode)), attributeTag);
}
@Override
public final String render(final NodeElement nodeElement) {
final String id = nodeElement.getId();
final String label = nodeElement.getLabel();
if (id.equals(label)) {
return quoted(id);
} else {
return quoted(id) + "[label=" + quoted(label) + CLOSE_BRACE;
}
}
}
|
package com.psy.sportsboard.user.dao;
import com.psy.sportsboard.sportsArticles.vo.SportsArticlesVO;
import com.psy.sportsboard.user.vo.UserVO;
public interface UserDao {
public int isExsistEmail(String email);
public int addUser(UserVO userVO);
public UserVO signIn(UserVO userVO);
public int updatePoint(SportsArticlesVO articlesVO);
}
|
package Negocio;
import java.util.List;
import Controlador.*;
public class Negocio {
public static void main(String [] arg) {
Controlador controlador=new Controlador();
Negocio negocio = new Negocio();
List<String> atributos=controlador.leerFichero("AtributosJuego.txt");
List<String> juego=controlador.leerFichero("Juego.txt");
negocio.algoritmoID3(atributos,juego);
}
public void algoritmoID3(List<String> atributos,List<String> juego)
{
}
}
|
package com.example.kyle.mystudentpal;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class syllabus extends ActionBarActivity{
int catNumTemp, catSum;
TextView title, catNum;
CheckBox points, percent;
EditText catWeight1, catWeight2, catWeight3, catWeight4, catWeight5, catWeight6;
LinearLayout pointsLayout, percentLayout, catLayout1, catLayout2, catLayout3, catLayout4, catLayout5, catLayout6;
Calendar calendar;
SimpleDateFormat dateFormat;
String year;
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.syllabus);
catNumTemp = 1;
catNum = (TextView)findViewById(R.id.numOfCategories);
title = (TextView)findViewById(R.id.syllabusTitle);
title.setText(term.getCourse());
points = (CheckBox)findViewById(R.id.pointsCheckBox);
percent = (CheckBox)findViewById(R.id.percentCheckBox);
pointsLayout = (LinearLayout)findViewById(R.id.pointsLayout);
percentLayout = (LinearLayout)findViewById(R.id.percentLayout);
catLayout1 = (LinearLayout)findViewById(R.id.catLL1);
catLayout2 = (LinearLayout)findViewById(R.id.catLL2);
catLayout3 = (LinearLayout)findViewById(R.id.catLL3);
catLayout4 = (LinearLayout)findViewById(R.id.catLL4);
catLayout5 = (LinearLayout)findViewById(R.id.catLL5);
catLayout6 = (LinearLayout)findViewById(R.id.catLL6);
catWeight1 = (EditText)findViewById(R.id.catWeight1);
catWeight2 = (EditText)findViewById(R.id.catWeight2);
catWeight3 = (EditText)findViewById(R.id.catWeight3);
catWeight4 = (EditText)findViewById(R.id.catWeight4);
catWeight5 = (EditText)findViewById(R.id.catWeight5);
catWeight6 = (EditText)findViewById(R.id.catWeight6);
calendar = Calendar.getInstance();
dateFormat = new SimpleDateFormat("yy");
year = dateFormat.format(calendar.getTime());
points.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton button, boolean isChecked) {
if (points.isChecked()) {
if(percent.isChecked())
percent.setChecked(false);
catNumTemp = 1;
catNum.setText(Integer.toString(catNumTemp) + "");
pointsLayout.setVisibility(View.VISIBLE);
}
else
pointsLayout.setVisibility(View.GONE);
}
});
percent.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton button, boolean isChecked) {
if (percent.isChecked()) {
if(points.isChecked())
points.setChecked(false);
catLayout2.setVisibility(View.INVISIBLE);
catLayout3.setVisibility(View.INVISIBLE);
catLayout4.setVisibility(View.INVISIBLE);
catLayout5.setVisibility(View.INVISIBLE);
catLayout6.setVisibility(View.INVISIBLE);
percentLayout.setVisibility(View.VISIBLE);
}
else
percentLayout.setVisibility(View.GONE);
}
});
}
public void syllabusFinish_onClick(View v){
catSum = Integer.parseInt(catWeight1.getText().toString()) + Integer.parseInt(catWeight2.getText().toString()) + Integer.parseInt(catWeight3.getText().toString())
+ Integer.parseInt(catWeight4.getText().toString()) + Integer.parseInt(catWeight5.getText().toString()) + Integer.parseInt(catWeight6.getText().toString());
if(percent.isChecked() || (!percent.isChecked() && !points.isChecked())) {
if (catSum == 100) {
if (term.courseNum == term.amount) {
Intent i = new Intent(getApplicationContext(), MainActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(i);
term.courseNum = 0;
} else {
Intent i = new Intent(this, course.class);
startActivity(i);
term.courseNum++;
}
} else if(catSum != 100 && percent.isChecked()){
Toast.makeText(this, "The sum of the category weights must be 100", Toast.LENGTH_LONG).show();
} else {
Toast.makeText(this, "You have not completed this page", Toast.LENGTH_LONG).show();
}
} else {
if (term.courseNum == term.amount) {
MainActivity.adapter.add(term.termSpinner.getSelectedItem().toString() + "\t" + year);
MainActivity.itemsInSpinner++;
Intent i = new Intent(getApplicationContext(), MainActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(i);
term.courseNum = 0;
} else {
Intent i = new Intent(this, course.class);
startActivity(i);
term.courseNum++;
}
}
}
public void syllabusBack_onClick(View v){
finish();
}
public void catPlus_onClick(View v){
if(catNumTemp == 1)
catLayout2.setVisibility(View.VISIBLE);
if(catNumTemp == 2)
catLayout3.setVisibility(View.VISIBLE);
if(catNumTemp == 3)
catLayout4.setVisibility(View.VISIBLE);
if(catNumTemp == 4)
catLayout5.setVisibility(View.VISIBLE);
if(catNumTemp == 5)
catLayout6.setVisibility(View.VISIBLE);
if(catNumTemp < 6)
catNumTemp++;
catNum.setText(Integer.toString(catNumTemp) + "");
}
public void catMinus_onClick(View v){
if(catNumTemp == 6)
catLayout6.setVisibility(View.INVISIBLE);
if(catNumTemp == 5)
catLayout5.setVisibility(View.INVISIBLE);
if(catNumTemp == 4)
catLayout4.setVisibility(View.INVISIBLE);
if(catNumTemp == 3)
catLayout3.setVisibility(View.INVISIBLE);
if(catNumTemp == 2)
catLayout2.setVisibility(View.INVISIBLE);
if(catNumTemp > 1)
catNumTemp--;
catNum.setText(Integer.toString(catNumTemp) + "");
}
}
|
package com.example.springbootdemo.service.country;
import com.example.springbootdemo.model.Country;
import com.example.springbootdemo.service.IGeneralService;
public interface ICountryService extends IGeneralService<Country> {
}
|
package dao;
import java.util.List;
import entidad.Provincias;
public interface DaoProvincias {
public List<Provincias> readAll();
public Provincias obtenerProvincia(String id_provincia);
}
|
package com.zxt.compplatform.formengine.service;
import java.util.Comparator;
import com.zxt.compplatform.formengine.entity.view.Tab;
/**
* tab比较器
* @author 007
*/
public class Comparat implements Comparator {
public int compare(Object o1, Object o2) {
Tab tab1 = (Tab) o1;
Tab tab2 = (Tab) o2;
if (tab1.getSortIndex() < tab2.getSortIndex())
return 1;
else
return 0;
}
}
|
package com.sportzcourt.booking.ui.activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.MenuItem;
import com.sportzcourt.booking.R;
import com.sportzcourt.booking.controller.DataController;
import com.sportzcourt.booking.service.webservices.ApiService;
import butterknife.ButterKnife;
/**
* Copyright 2016 (C) Happiest Minds Pvt Ltd..
*
* <P> Base activity for a Bootstrap activity which does not use fragments
*
* <P>Notes:
* <P>Dependency:
*
* @authors Ravindra Kamble (ravindra.kambale@happiestminds.com)
*
* @created on: 5-Jan-2016
*/
public abstract class BootstrapActivity extends AppCompatActivity {
public ApiService apiService;
/** The progress dialog. */
private ProgressDialog progressDialog;
/**
* Class tag. Used for debug.
*/
private String TAG;
@Override
protected void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TAG = this.getClass().getCanonicalName();
apiService = DataController.getInstance().getAPIManager();
}
@Override
public void setContentView(final int layoutResId) {
super.setContentView(layoutResId);
// Used to inject views with the Butterknife library
ButterKnife.bind(this);
}
@Override
public boolean onOptionsItemSelected(final MenuItem item) {
switch (item.getItemId()) {
// This is the home button in the top left corner of the screen.
case android.R.id.home:
// Don't call finish! Because activity could have been started by an
// outside activity and the home button would not operated as expected!
final Intent homeIntent = new Intent(this, MainActivity.class);
//homeIntent.addFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
startActivity(homeIntent);
return true;
default:
return super.onOptionsItemSelected(item);
}
}
/**
* Show progress dialog.
*/
public final void showProgressDialog() {
progressDialog = new ProgressDialog(this);
progressDialog.setCanceledOnTouchOutside(false);
progressDialog.setMessage(getString(R.string.loading));
progressDialog.show();
}
/**
* Hide progress dialog.
*/
public final void hideProgressDialog() {
if (null != progressDialog) {
progressDialog.dismiss();
progressDialog.cancel();
}
progressDialog = null;
}
}
|
package com.fatihdogan.datastructure;
import com.fatihdogan.datastructure.list.ArrayListClass;
import com.fatihdogan.datastructure.list.CompareArrayListNikedList;
import com.fatihdogan.datastructure.list.LinkedListClass;
import com.fatihdogan.datastructure.map.HashMapClass;
import com.fatihdogan.datastructure.map.MapClass;
import com.fatihdogan.datastructure.set.SetClass;
public class Main {
public static void main(String[] args) {
ArrayListClass arrayList = new ArrayListClass();
// arrayList.Test();
LinkedListClass linkedList = new LinkedListClass();
//linkedList.Test();
CompareArrayListNikedList compare = new CompareArrayListNikedList();
// compare.Test();
SetClass setClass = new SetClass();
// setClass.Test();
HashMapClass hash = new HashMapClass();
// hash.Test();
MapClass map = new MapClass();
// map.Test();
Test tt = new Test();
tt.Test();
}
}
|
package com.j1902.shopping.mapper;
import com.j1902.shopping.pojo.Order;
import com.j1902.shopping.pojo.OrderExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
public interface OrderMapper {
long countByExample(OrderExample example);
int insertByOrder(Order record);
int deleteByExample(OrderExample example);
int deleteByPrimaryKey(Integer orderId);
int insert(Order record);
int insertSelective(Order record);
List<Order> selectByExample(OrderExample example);
List<Order> selectByCountId(@Param("id") Integer id);
Order selectByPrimaryKey(Integer orderId);
int updateByExampleSelective(@Param("record") Order record, @Param("example") OrderExample example);
int updateByExample(@Param("record") Order record, @Param("example") OrderExample example);
int updateByPrimaryKeySelective(Order record);
int updateByPrimaryKey(Order record);
}
|
package com.jim.mybatis.model.mapper;
import com.jim.mybatis.model.po.UserRole;
public interface UserRoleMapper {
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table user_role
*
* @mbggenerated Thu Sep 21 01:16:58 CST 2017
*/
int insert(UserRole record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table user_role
*
* @mbggenerated Thu Sep 21 01:16:58 CST 2017
*/
int insertSelective(UserRole record);
}
|
package com.cos.blog.service;
import java.util.List;
import com.cos.blog.domain.board.Board;
import com.cos.blog.domain.board.BoardDao;
import com.cos.blog.domain.board.dto.DetailRespDto;
import com.cos.blog.domain.board.dto.SaveReqDto;
import com.cos.blog.domain.board.dto.UpdateReqDto;
public class BoardService {
private BoardDao boardDao;
public BoardService() {
boardDao = new BoardDao();
}
public int 글쓰기(SaveReqDto dto) {
return boardDao.save(dto);
}
public List<Board> 목록보기(int page) {
return boardDao.findAll(page);
}
public DetailRespDto 상세보기(int boardId) {
boardDao.updateReadCount(boardId);
return boardDao.findById(boardId);
}
public int 게시물갯수세기() {
return boardDao.count();
}
public int 게시물갯수세기(String keyword) {
return boardDao.count(keyword);
}
public int 게시물삭제(int boardId) {
return boardDao.deleteById(boardId);
}
public int 게시물수정(UpdateReqDto dto) {
return boardDao.update(dto);
}
public List<Board> 키워드검색(String keyword, int page) {
return boardDao.findByKeyword(keyword, page);
}
}
|
package com.example.smsviawifi;
import java.io.File;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.ContactsContract;
import android.provider.ContactsContract.PhoneLookup;
public class ContactsRetriever extends Thread{
public static Context context = MyApplication.getAppContext();
static ContentResolver cr = context.getContentResolver();
public static void readContacts() {
Cursor cur = cr.query(ContactsContract.Contacts.CONTENT_URI, null,
null, null, null);
String allContacts = "{\"contacts\" :[\n";
if (cur.getCount() > 0) {
while (cur.moveToNext()) {
String id = cur.getString(cur
.getColumnIndex(ContactsContract.Contacts._ID));
String name = cur
.getString(cur
.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
if (Integer
.parseInt(cur.getString(cur
.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER))) > 0) {
// Log.i("WIFISMS","name : " + name + ", ID : " + id);
allContacts = allContacts + "{\n" + "\"ID\":\"" + id
+ "\",\n" + "\"name\":\"" + name + "\",\n"
+ "\"numbers\":[";
// get the phone number
Cursor pCur = cr.query(
ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
null,
ContactsContract.CommonDataKinds.Phone.CONTACT_ID
+ " = ?", new String[] { id }, null);
boolean noNum=true;
while (pCur.moveToNext()) {
String phone = pCur
.getString(pCur
.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
// Log.i("WIFISMS","phone" + phone);
allContacts = allContacts + "\"" + phone + "\",";
noNum=false;
}
pCur.close();
if(noNum) allContacts = allContacts + "-";
allContacts = allContacts.substring(0,
allContacts.length() - 1);
allContacts = allContacts + "]\n" + "}";
allContacts = allContacts + ",";
}
}
allContacts = allContacts.substring(0, allContacts.length() - 1)
+ "]}";
}
FileRead.writeFile(context.getFilesDir().getPath() + File.separator
+ "Data" + File.separator + "contacts" + File.separator,
"contacts-list.json", allContacts);
synchronized(MainActivity.lock){
MainActivity.contactsLoaded = true;
}
cur.close();
}
public static String getContactId(String phoneNumber, Context context) {
ContentResolver mResolver = context.getContentResolver();
Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,
Uri.encode(phoneNumber));
Cursor cursor = mResolver.query(uri, new String[] {
PhoneLookup.DISPLAY_NAME, PhoneLookup._ID }, null, null, null);
String contactId = "";
if (cursor.moveToFirst()) {
do {
contactId = cursor.getString(cursor
.getColumnIndex(PhoneLookup._ID));
} while (cursor.moveToNext());
}
cursor.close();
cursor = null;
return contactId;
}
public static String getContactName(String phoneNumber, Context context) {
ContentResolver mResolver = context.getContentResolver();
Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,
Uri.encode(phoneNumber));
Cursor cursor = mResolver.query(uri, new String[] {
PhoneLookup.DISPLAY_NAME, PhoneLookup._ID }, null, null, null);
String contactId = "";
if (cursor.moveToFirst()) {
do {
contactId = cursor.getString(cursor
.getColumnIndex(PhoneLookup.DISPLAY_NAME));
} while (cursor.moveToNext());
}
cursor.close();
cursor = null;
return contactId;
}
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
readContacts();
}
}
|
package com.android.app.warehousemanagement.db;
import java.util.ArrayList;
import java.util.HashMap;
import org.json.JSONException;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.graphics.PixelFormat;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.SeekBar;
import android.widget.TextView;
import com.android.app.warehousemanagement.R;
import com.android.app.warehousemanagement.SingleRecordActivity;
import com.android.app.warehousemanagement.db.OutterDBExec.OutterDBException;
public class SqlDBInterface {
//0-INNER SERVER; 1-PRODUCTION SERVER
private static int server = 1;
private InnerDBExec innerDB = null;
private OutterDBExec outterDB = null;
private Context context;
private Boolean isWaiting = true;
private View waitView = null;
public SqlDBInterface (Context _context){
context = _context;
innerDB = new InnerDBExec(context);
outterDB = new OutterDBExec();
}
public Context getContext(){
return context;
}
public void showExceptionDialog(OutterDBException e){
AlertDialog.Builder completeDialog = new Builder(context);
completeDialog.setMessage(e.getMessage());
completeDialog.setTitle(e.getTitle());
completeDialog.setPositiveButton("确认", new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
completeDialog.create().show();
}
public void showWaiting(boolean isBlur, boolean isUpload) {
isWaiting = true;
WindowManager.LayoutParams lp = null;
if (isBlur) {
lp = new WindowManager.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, WindowManager.LayoutParams.TYPE_APPLICATION, WindowManager.LayoutParams.FLAG_FULLSCREEN | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, PixelFormat.TRANSLUCENT);
}
else {
lp = new WindowManager.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, WindowManager.LayoutParams.TYPE_APPLICATION, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, PixelFormat.TRANSLUCENT);
}
WindowManager mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
if (waitView == null) {
LayoutInflater inflate = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
waitView = inflate.inflate(R.layout.waiting_dialog, null);
}
if (isUpload) {
((TextView)waitView.findViewById(R.id.waitingDialogTypeText)).setText("数据 上传中");
}
else {
((TextView)waitView.findViewById(R.id.waitingDialogTypeText)).setText("数据加载中");
}
((TextView)waitView.findViewById(R.id.waitingDialogProgressText)).setText("(0%)");
((SeekBar)waitView.findViewById(R.id.waitDialogSeekBar)).setProgress(0);
mWindowManager.addView(waitView, lp);
}
public void setWaiting(int progress){
if (waitView != null){
((TextView)waitView.findViewById(R.id.waitingDialogProgressText)).setText("("+progress+"%)");
((SeekBar)waitView.findViewById(R.id.waitDialogSeekBar)).setProgress(progress);
}
}
public void hideWaiting() {
isWaiting = false;
try {
if (waitView != null) {
WindowManager mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
mWindowManager.removeView(waitView);
waitView = null;
}
}
catch (Throwable e) {
Log.e("waitView", "[showWaiting]", e);
}
}
public ArrayList<HashMap<String, Object>> warehouseSelectAll() throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = null;
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.warehouseSelectAll();
}
return arrayList;
}
public ArrayList<HashMap<String, Object>> currentSearch(String keyword, String sortby) throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = new ArrayList<HashMap<String, Object>>();
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.currentSearch(keyword, sortby);
}
for (int i=0; i<arrayList.size(); i++){
HashMap<String,Object> map = arrayList.get(i);
if (Integer.parseInt(map.get(SqlDBTable.Entry.COLUMN_NAME_TYPE).toString()) == 0){
map.put(SqlDBTable.Entry.COLUMN_NAME_TYPE, R.drawable.icon_material);
}
else {
map.put(SqlDBTable.Entry.COLUMN_NAME_TYPE, R.drawable.icon_product);
}
}
return arrayList;
}
public ArrayList<HashMap<String, Object>> recordSearch(String keyword, String sortby, String startdate, String enddate) throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = new ArrayList<HashMap<String, Object>>();
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.recordSearch(keyword, sortby, startdate, enddate);
}
for (int i=0; i<arrayList.size(); i++){
HashMap<String,Object> map = arrayList.get(i);
if (Integer.parseInt(map.get(SqlDBTable.Entry.COLUMN_NAME_TYPE).toString()) == 0){
map.put(SqlDBTable.Entry.COLUMN_NAME_TYPE, R.drawable.icon_material);
}
else {
map.put(SqlDBTable.Entry.COLUMN_NAME_TYPE, R.drawable.icon_product);
}
if (Integer.parseInt(map.get(SqlDBTable.Record.COLUMN_NAME_INOROUT).toString()) == 0){
map.put(SqlDBTable.Record.COLUMN_NAME_INOROUT, R.drawable.icon_instock);
}
else {
map.put(SqlDBTable.Record.COLUMN_NAME_INOROUT, R.drawable.icon_outstock);
}
if (Integer.parseInt(map.get(SqlDBTable.Record.COLUMN_NAME_STATUS).toString()) == 0){
map.put(SqlDBTable.Record.COLUMN_NAME_STATUS, R.drawable.icon_pending);
}
else {
map.put(SqlDBTable.Record.COLUMN_NAME_STATUS, R.drawable.icon_pass);
}
}
return arrayList;
}
public ArrayList<HashMap<String, Object>> currentSelectByNameAndType (String name, int type) throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = new ArrayList<HashMap<String, Object>>();
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.currentSelectByNameAndType(name, type);
}
return arrayList;
}
public ArrayList<HashMap<String, Object>> recordSelectByNameAndType (String name, int type, String sortby) throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = new ArrayList<HashMap<String, Object>>();
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.recordSelectByNameAndType(name, type, sortby);
}
for (int i=0; i<arrayList.size(); i++){
HashMap<String,Object> map = arrayList.get(i);
if (Integer.parseInt(map.get(SqlDBTable.Record.COLUMN_NAME_INOROUT).toString()) == 0){
map.put(SqlDBTable.Record.COLUMN_NAME_INOROUT, R.drawable.icon_instock);
}
else {
map.put(SqlDBTable.Record.COLUMN_NAME_INOROUT, R.drawable.icon_outstock);
}
if (Integer.parseInt(map.get(SqlDBTable.Record.COLUMN_NAME_STATUS).toString()) == 0){
map.put(SqlDBTable.Record.COLUMN_NAME_STATUS, R.drawable.icon_pending);
}
else {
map.put(SqlDBTable.Record.COLUMN_NAME_STATUS, R.drawable.icon_pass);
}
}
return arrayList;
}
public HashMap<String, Object> recordSelectById (int id) throws OutterDBException{
HashMap<String, Object> map = new HashMap<String, Object>();
if (server == 0){
}
else if (server == 1){
map = outterDB.recordSelectById(id);
}
return map;
}
public ArrayList<HashMap<String, Object>> entrySelectAll () throws OutterDBException{
ArrayList<HashMap<String, Object>> arrayList = new ArrayList<HashMap<String, Object>>();
if (server == 0){
}
else if (server == 1){
arrayList = outterDB.entrySelectAll();
}
return arrayList;
}
public void recordInsert (String name, int type, String unit, int inorout, int amount, int warehouseId, String remark) throws OutterDBException{
if (server == 0){
}
else if (server == 1){
outterDB.recordInsert(name, type, unit, inorout, amount, warehouseId, remark);
}
}
public int entrySelectUsableAmount (int entryId, int warehouseId) throws OutterDBException{
int usableAmount = 0;
if (server == 0){
}
else if (server == 1){
usableAmount = outterDB.entrySelectUsableAmount(entryId, warehouseId);
}
return usableAmount;
}
public void recordUpdate (int recordId) throws OutterDBException{
if (server == 0){
}
else if (server == 1){
outterDB.recordUpdate(recordId);
}
}
public void recordDelete (int recordId) throws OutterDBException{
if (server == 0){
}
else if (server == 1){
outterDB.recordDelete(recordId);
}
}
}
|
package com.example.federation.Events;
import android.app.ProgressDialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.Toast;
import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.example.federation.R;
import com.example.federation.SQLite.DatabaseLRHandler;
import com.example.federation.Volley.MyVolleyClass;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class UploadImage extends AppCompatActivity {
private EditText eDesc;
private ImageView iB;
private Button bSubmit;
private Bitmap bitmap;
final private int PICK_IMAGE = 1;
private Uri imageUri;
private static final int GALLERY_REQUEST=1;
private ProgressDialog progressDialog;
String selectedPath="";
private String uploadUrl="https://tsafindia.org/tsafadminpanel/tsaf/Appcontrollers/uploadImage";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_image_upload);
eDesc=(EditText)findViewById(R.id.descriptionField);
iB=(ImageView) findViewById(R.id.imageSelect);
bSubmit=(Button)findViewById(R.id.submitImage);
iB.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(Intent.createChooser(intent, ""), PICK_IMAGE);
}
});
bSubmit.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(!(selectedPath.trim().equalsIgnoreCase(""))){
Runnable uploadImageThread=new Runnable() {
@Override
public void run() {
uploadImage();
}
};
uploadImageThread.run();
}else{
Toast.makeText(getApplicationContext(),"Please select files to upload.", Toast.LENGTH_SHORT).show();
}
}
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if(requestCode==GALLERY_REQUEST && resultCode==RESULT_OK && data!=null){
Uri path=data.getData();
try {
bitmap=MediaStore.Images.Media.getBitmap(getContentResolver(),path);
iB.setImageBitmap(bitmap);
selectedPath=path.getPath();
Log.d("path",path.getPath());
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void uploadImage(){
float height=bitmap.getHeight();
float width=bitmap.getWidth();
float ratio=width/height;
Bitmap resizedImage=getResizedBitmap(bitmap,400,400*ratio);
final String imageInString=bitmapToString(resizedImage);
StringRequest stringRequest=new StringRequest(Request.Method.POST, uploadUrl, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.d("response",response);
Toast.makeText(getApplicationContext(),"Image uploaded successfully!",Toast.LENGTH_SHORT).show();
Intent intent=new Intent(getApplicationContext(),EventInformationActivity.class);
intent.putExtra("eventCode",getIntent().getStringExtra("eventCode"));
intent.putExtra("eventName",getIntent().getStringExtra("eventName"));
intent.putExtra("eventId",getIntent().getIntExtra("eventId",0));
startActivity(intent);
finish();
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
Log.d("error",error.toString());
Toast.makeText(getApplicationContext(),"Something went wrong try again!",Toast.LENGTH_SHORT).show();
}
}){
@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String,String> map=new HashMap<>();
map.put("imageDescription",eDesc.getText().toString().trim());
map.put("imageData",imageInString);
map.put("eventCode",getIntent().getStringExtra("eventCode"));
DatabaseLRHandler db=new DatabaseLRHandler(getApplicationContext());
JSONArray jsonArray=db.getEventData(getIntent().getIntExtra("eventId",0));
for(int i=0;i<jsonArray.length();i++){
try {
JSONObject jsonObject=jsonArray.getJSONObject(i);
map.put("eventName",jsonObject.getString("eventName"));
map.put("eventVenue",jsonObject.getString("eventVenue"));
map.put("eventStartingDate",jsonObject.getString("eventStartingDate"));
map.put("eventEndingDate",jsonObject.getString("eventEndingDate"));
} catch (JSONException e) {
e.printStackTrace();
}
}
SharedPreferences pref=getApplicationContext().getSharedPreferences("Tata",MODE_PRIVATE);
map.put("instructorName",pref.getString("name",""));
map.put("instructorEmail",pref.getString("email",""));
return map;
}
};
MyVolleyClass.getInstance(getApplicationContext()).addToRequestQueue(stringRequest);
}
private String bitmapToString(Bitmap bitmap){
ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG,100,byteArrayOutputStream);
byte[] byteArray=byteArrayOutputStream.toByteArray();
return Base64.encodeToString(byteArray,Base64.DEFAULT);
}
public Bitmap getResizedBitmap(Bitmap bm, float newHeight, float newWidth) {
int width = bm.getWidth();
int height = bm.getHeight();
float scaleWidth = ( (float)newWidth) / width;
float scaleHeight = ( (float)newHeight) / height;
// CREATE A MATRIX FOR THE MANIPULATION
Matrix matrix = new Matrix();
// RESIZE THE BIT MAP
matrix.postScale(scaleWidth, scaleHeight);
// RECREATE THE NEW BITMAP
Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, false);
return resizedBitmap;
}
private Bitmap loadImage(String imgPath) {
BitmapFactory.Options options;
try {
options = new BitmapFactory.Options();
options.inSampleSize = 2;
Bitmap bitmap = BitmapFactory.decodeFile(imgPath, options);
return bitmap;
} catch(Exception e) {
e.printStackTrace();
}
return null;
}
public String getAbsolutePath(Uri uri) {
String[] projection = { MediaStore.MediaColumns.DATA };
@SuppressWarnings("deprecation")
Cursor cursor = managedQuery(uri, projection, null, null, null);
if (cursor != null) {
int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA);
cursor.moveToFirst();
return cursor.getString(column_index);
} else
return null;
}
/*
class ImageUploadTask extends AsyncTask<Void, Void, String> {
private String webAddressToPost = "http://your-website-here.com";
// private ProgressDialog dialog;
private ProgressDialog dialog = new ProgressDialog(MainActivity.this);
@Override
protected void onPreExecute() {
dialog.setMessage("Uploading...");
dialog.show();
}
@Override
protected String doInBackground(Void... params) {
try {
HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpPost httpPost = new HttpPost(webAddressToPost);
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.JPEG, 100, bos);
byte[] data = bos.toByteArray();
String file = Base64.encodeBytes(data);
entity.addPart("uploaded", new StringBody(file));
entity.addPart("someOtherStringToSend", new StringBody("your string here"));
httpPost.setEntity(entity);
HttpResponse response = httpClient.execute(httpPost,localContext);
BufferedReader reader = new BufferedReader(new InputStreamReader(
response.getEntity().getContent(), "UTF-8"));
String sResponse = reader.readLine();
return sResponse;
} catch (Exception e) {
// something went wrong. connection with the server error
}
return null;
}
@Override
protected void onPostExecute(String result) {
dialog.dismiss();
Toast.makeText(getApplicationContext(), "file uploaded",Toast.LENGTH_LONG).show();
}
}
/* private void doFileUpload(){
File file = new File(selectedPath);
String urlString = "http://10.0.2.2/upload_test/upload_media_test.php";
try
{
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(urlString);
FileBody bin = new FileBody(file);
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart("uploadedfile", bin);
reqEntity.addPart("user", new StringBody("User"));
post.setEntity(reqEntity);
HttpResponse response = client.execute(post);
resEntity = response.getEntity();
final String response_str = EntityUtils.toString(resEntity);
if (resEntity != null) {
Log.i("RESPONSE",response_str);
runOnUiThread(new Runnable(){
public void run() {
try {
res.setTextColor(Color.GREEN);
res.setText("n Response from server : n " + response_str);
Toast.makeText(getApplicationContext(),"Upload Complete. Check the server uploads directory.", Toast.LENGTH_LONG).show();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
}
catch (Exception ex){
Log.e("Debug", "error: " + ex.getMessage(), ex);
}
}*/
}
|
package MachineLearning;
public class GetLevel {
public static String getLevel(String level){
if(level.equals("1")){
return "1,0,0,0";
}
else if(level.equals("2")){
return "0,1,0,0";
}
else if(level.equals("3")){
return "0,0,1,0";
}
else if(level.equals("3")){
return "0,0,0,1";
}
else{
return "0,0,0,0";
}
}
}
|
package com.example.user.entity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* @ClassName: User
* @Description: 用户实体类
* @Author: yongchen
* @Date: 2020/10/22 10:46
**/
@Data
@EqualsAndHashCode(callSuper = false)
@Builder
public class User {
@ApiModelProperty("用户ID")
private Long id;
@ApiModelProperty("用户名")
private String username;
@ApiModelProperty("密码")
private String password;
}
|
package org.openmrs.module.mirebalais.apploader.apps;
import org.openmrs.module.appframework.domain.AppDescriptor;
import org.openmrs.module.mirebalais.MirebalaisConstants;
import org.openmrs.module.mirebalais.apploader.CustomAppLoaderConstants;
import org.openmrs.module.pihcore.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import static org.openmrs.module.mirebalais.apploader.CustomAppLoaderUtil.app;
import static org.openmrs.module.mirebalais.apploader.CustomAppLoaderUtil.objectNode;
@Component
public class GraphFactory {
private Config config;
@Autowired
public GraphFactory(Config config) {
this.config = config;
}
public AppDescriptor getBloodPressureGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.BLOOD_PRESSURE_GRAPH + extensionPoint,
"pih.app.bloodPressure.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.bloodPressure.graph.title",
"conceptId", MirebalaisConstants.DIASTOLIC_BP_CONCEPT_UUID + ","
+ MirebalaisConstants.SYSTOLIC_BP_CONCEPT_UUID,
"maxResults", "10"
));
}
public AppDescriptor getBmiGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.BMI_GRAPH + extensionPoint,
"pih.app.bmiGraph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.bmiGraph.title",
"conceptId", MirebalaisConstants.WEIGHT_CONCEPT_UUID + ","
+ MirebalaisConstants.HEIGHT_CONCEPT_UUID,
"function", "(bmi, "
+ MirebalaisConstants.HEIGHT_CONCEPT_UUID + ", "
+ MirebalaisConstants.WEIGHT_CONCEPT_UUID + ");", // the order of the parameters is important
"maxResults", "12" // TODO what should this be?
));
}
public AppDescriptor getCholesterolGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.CHOLESTEROL_GRAPH + extensionPoint,
"pih.app.cholesterolGraph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.cholesterolGraph.title",
"conceptId", MirebalaisConstants.TOTAL_CHOLESTEROL_CONCEPT_UUID + ","
+ MirebalaisConstants.HDL_CONCEPT_UUID + ","
+ MirebalaisConstants.LDL_CONCEPT_UUID,
"maxRecords", "10"
));
}
public AppDescriptor getWHODASGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.WHODAS_GRAPH + extensionPoint,
"pih.app.whodas.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.whodas.graph.title",
"conceptId", MirebalaisConstants.WHODAS,
"maxRecords", "12"
));
}
public AppDescriptor getZLDSIGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.ZLDSI_GRAPH + extensionPoint,
"pih.app.zldsi.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.zldsi.graph.title",
"conceptId", MirebalaisConstants.ZLDSI,
"maxRecords", "12"
));
}
public AppDescriptor getSeizureFrequencyGraph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.SEIZURE_FREQUENCY_GRAPH + extensionPoint,
"pih.app.seizure.frequency.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.seizure.frequency.graph.title",
"conceptId", MirebalaisConstants.SEIZURE_FREQUENCY,
"maxRecords", "12"
));
}
public AppDescriptor getPHQ9Graph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.PHQ9_GRAPH + extensionPoint,
"pih.app.phq9.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.phq9.graph.title",
"conceptId", MirebalaisConstants.PHQ9,
"maxRecords", "12"
));
}
public AppDescriptor getGAD7Graph(String extensionPoint) {
return app(
CustomAppLoaderConstants.Apps.GAD7_GRAPH + extensionPoint,
"pih.app.gad7.graph.title",
"icon-bar-chart",
null,
null,
objectNode(
"widget", "obsgraph",
"icon", "icon-bar-chart",
"label", "pih.app.gad7.graph.title",
"conceptId", MirebalaisConstants.GAD7,
"maxRecords", "12"
));
}
}
|
package br.com.salon.carine.lima.repositoriessdp;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import br.com.salon.carine.lima.models.Usuario;
@Repository
public interface UsuarioRepositorySJPA extends JpaRepository<Usuario, String>{
Optional<Usuario> findByEmail(String email);
Optional<Usuario> findBySalt(String salt);
}
|
/*
* Copyright (c) 2017, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.oracle.truffle.llvm.nodes.intrinsics.llvm.debug;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.dsl.Cached;
import com.oracle.truffle.api.dsl.NodeChild;
import com.oracle.truffle.api.dsl.NodeChildren;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.FrameSlot;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.ExplodeLoop;
import com.oracle.truffle.llvm.runtime.debug.LLVMDebugValueProvider;
import com.oracle.truffle.llvm.runtime.debug.LLVMDebugValue;
import com.oracle.truffle.llvm.runtime.nodes.api.LLVMExpressionNode;
public abstract class LLVMDebugFrameWriteNode extends LLVMExpressionNode {
private final FrameSlot frameSlot;
protected LLVMDebugFrameWriteNode(FrameSlot frameSlot) {
this.frameSlot = frameSlot;
}
public FrameSlot getFrameSlot() {
return frameSlot;
}
@NodeChild(value = "valueRead", type = LLVMExpressionNode.class)
public abstract static class WriteNode extends LLVMDebugFrameWriteNode {
private final LLVMDebugBuilder processorBuilder;
protected WriteNode(FrameSlot frameSlot, LLVMDebugBuilder processorBuilder) {
super(frameSlot);
this.processorBuilder = processorBuilder;
}
protected LLVMDebugValueProvider.Builder createBuilder() {
return processorBuilder.createBuilder(getContextReference());
}
@Specialization
protected Object write(VirtualFrame frame, Object llvmValue, @Cached("createBuilder()") LLVMDebugValueProvider.Builder valueProcessor) {
final LLVMDebugValue value = LLVMDebugValue.create(valueProcessor, llvmValue);
frame.setObject(getFrameSlot(), value);
return null;
}
}
public abstract static class AggregateInitNode extends LLVMDebugFrameWriteNode {
@CompilerDirectives.CompilationFinal(dimensions = 1) private int[] offsets;
@CompilerDirectives.CompilationFinal(dimensions = 1) private int[] lengths;
protected AggregateInitNode(FrameSlot frameSlot, int[] offsets, int[] lengths) {
super(frameSlot);
this.offsets = offsets;
this.lengths = lengths;
}
@Specialization
protected Object init(VirtualFrame frame) {
frame.setObject(getFrameSlot(), new LLVMDebugAggregateValue(offsets, lengths));
return null;
}
}
@NodeChildren({
@NodeChild(value = "aggregateRead", type = LLVMExpressionNode.class),
@NodeChild(value = "llvmValueRead", type = LLVMExpressionNode.class)
})
public abstract static class AggregateWriteNode extends LLVMDebugFrameWriteNode {
private final int partIndex;
private final LLVMDebugBuilder builder;
@CompilerDirectives.CompilationFinal(dimensions = 1) private final int[] clearIndices;
protected AggregateWriteNode(FrameSlot frameSlot, int partIndex, LLVMDebugBuilder builder, int[] clearIndices) {
super(frameSlot);
this.partIndex = partIndex;
this.builder = builder;
this.clearIndices = clearIndices;
}
protected LLVMDebugValueProvider.Builder createBuilder() {
return builder.createBuilder(getContextReference());
}
@Specialization
protected Object setPart(LLVMDebugAggregateValue aggregate, Object partLLVMValue, @Cached("createBuilder()") LLVMDebugValueProvider.Builder valueProcessor) {
aggregate.setPart(partIndex, valueProcessor, partLLVMValue);
clearIndices(aggregate);
return null;
}
@ExplodeLoop
private void clearIndices(LLVMDebugAggregateValue value) {
for (int i : clearIndices) {
value.clear(i);
}
}
}
}
|
package com.enedis.ludovic;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Random;
import java.util.Scanner;
import static java.lang.Character.isDigit;
/**
* Classe avec les méthodes outils pour les deux jeux
*/
public class Tools {
private static final Logger logger = LogManager.getLogger();
/**
* Méthode pour générer un nombre aléatoire
*
* @param longNbAleaConf la longueur du nombre devant être gégéré
* @param lowBound limite basse pour la génération du chiffre aléatoire
* @param highBound limite haute pour la génération du
* @return le nombre aléatoire dans un type StringBuilder
*/
public static StringBuilder geneNbAlea(int longNbAleaConf, int lowBound, int highBound) {
Random r = new Random();
StringBuilder nbAlea = new StringBuilder();
for (int i = 0; i < longNbAleaConf; i++) {
int geneNbAlea = lowBound + r.nextInt(highBound - lowBound);
nbAlea.insert(i, geneNbAlea);
}
return nbAlea;
}
/**
* Méthode permettant de tester la victoire ou non du joueur
*
* @param reponse reponse donné par le défenseur (avec les signes + - =)
* @param longNbAlea longueur du nombre aléatoire
* @return false: Mauvaise combianaison, true: Bonne combinaison
*/
public static boolean combinaisonValide(StringBuilder reponse, int longNbAlea) {
for (int i = 0; i < longNbAlea; i++) {
if (reponse.charAt(i) != '=') {
logger.info("La réponse n'est pas la bonne");
return false;
}
}
logger.info("La réponse est la bonne");
return true;
}
/**
* Cette méthode permet d'afficher le tour en cour ainsi que d'aérer un peu la lecture de la console
*
* @param numeroTour numéro du tour en cours
* @param nombreDeTourConf nombre de tour possible configuré
*/
public static void affichageTour(int numeroTour, int nombreDeTourConf) {
int nbTourRestant = nombreDeTourConf - numeroTour;
System.out.println("\n" + "**********************************************");
System.out.println("Tour n°" + numeroTour + "(nombre de tour restant: " + nbTourRestant + ")");
System.out.println("**********************************************" + "\n");
}
/**
* Cette méthode permet d'afficher le gagnant
* @param winLoose le boolean qui désigne le gagnant
*/
public static void winLoose(boolean winLoose) {
if (!winLoose) {
System.out.println("L'ordinateur à perdu !");
logger.info("Le joueur a gagné, l'ordinateur a perdu");
} else {
System.out.println("L'ordinateur a gagné !");
logger.info("L'ordinateur a gagné, le joueur a perdu");
}
}
/**
* Cette méthode permet un affichage en devMode de la combinaison secrète que le joueur doit trouver.
*
* @param combinaisonSecrete la valeur que le joueur doit trouver
*/
public static void devMode(StringBuilder combinaisonSecrete) {
System.out.println("\n" + "----------------DEV MODE ACTIF------------------");
System.out.println("La combinaison secrète est : " + combinaisonSecrete);
System.out.println("--------------------------------------------------" + "\n");
}
/**
* Cette méthode permet d'afficher le gagant en fonction d'un int
*
* @param numeroGagnant numéro du gagant
*/
public static void gagnant(int numeroGagnant) {
switch (numeroGagnant) {
case 1:
System.out.println("L'ordinateur a gagné !");
logger.info("L'ordinateur a gagné, le joueur a perdu");
break;
case 2:
System.out.println("Vous avez gagné !");
logger.info("Le joueur a gagné, l'ordinateur a perdu");
break;
}
}
/**
* Cette méthode permet de récuperer la saisie de l'utilisateur, elle ne récupère que les signes =, - ou + et les retourne en String
* Elle vérifie également que la saisie est de la bonne longueur
*
* @param longNbAleaConf longueur du nombre aléatoire
* @return la saisie de l'utilisateur de longueur longNbAleaConf en String
*/
public static String saisieSignes(int longNbAleaConf) {
String saisie;
boolean test = false ;
Scanner sc = new Scanner(System.in);
do {
System.out.println("Merci de saisir votre réponse ("+longNbAleaConf+" signes)");
saisie = sc.next();
if (saisie.length() == longNbAleaConf) {
for (int i = 0; i < longNbAleaConf; i++)
if (saisie.charAt(i) != '+' && saisie.charAt(i) != '-' && saisie.charAt(i) != '=') {
test = false;
break;
} else {
test = true;
}
}else{
logger.info("La saisie n'est pas de la bonne longueur");
System.out.println("Votre saisie n'est pas de la bonne longueur, merci d'essayer à nouveau");
}
}while (!test);
return saisie;
}
/**
* Cette méthode permet de récupérer la saisie de l'utilisateur, d'une bonne longueur, avec que des chiffres et compris dans les bonne bornes
* @param longNbAleaConf longueur du nombre aléatoire
* @param lowBound limite basse de saisie
* @param highBound limite haute de saisie
* @return la saisie de l'utilisateur
*/
public static String saisieNumero(int longNbAleaConf, int lowBound, int highBound){
String saisieUtil;
Scanner sc = new Scanner(System.in);
boolean saisieCorrect ;
boolean saisieTotalOk = false;
do {
logger.info("Demande de saisie au joueur");
System.out.println("Merci de saisir " + longNbAleaConf + " chiffres, compris entre "+lowBound+" et "+highBound);
saisieUtil = sc.next();
if (saisieUtil.length() == longNbAleaConf) {
for (int i = 0; i < longNbAleaConf; i++) {
int y = Character.getNumericValue(saisieUtil.charAt(i));
saisieCorrect = isDigit(saisieUtil.charAt(i));
if (y >= lowBound && y <= highBound && saisieCorrect) {
saisieTotalOk = true;
} else {
saisieTotalOk = false;
logger.info("La saisie ne comporte pas que des chiffres ou n'est pas compris entre les bornes");
break;
}
}
} else {
logger.info("La saisie n'est pas de la bonne longueur");
}
}while (!saisieTotalOk);
return saisieUtil;
}
}
|
package sampleproject.db;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.regex.PatternSyntaxException;
/**
* A DvdDatabase object provides access to all of the Dvds in the system and
* all the operations that act upon the dvds.
* <br/>
* This is the only class that a programmer should use to access or modify the
* Dvds. This class uses the Facade design pattern (this class calls other
* classes, of which the end user has no knowledge). This enables us to write
* classes in the db package that have only a single responsibility (easier to
* code and maintain), while giving users of our package one simple set of APIs
* the can call for all access to the database.
* <br />
* This class also uses the Adapter pattern, changing method calls to suit
* the requirements of the classes it calls - as an example, check out the
* <code>reserveDvd</code> and <code>releaseDvd</code> methods.
* <br />
* One instance of this class should be created for each connected client. The
* instance of this class can then be used to identify the client to the
* reservations module.
*
* @author Denny's DVDs
* @version 2.0
*/
public class DvdDatabase implements DBClient {
/**
* A static structure that keeps track of the locked Dvd records.
*/
private static ReservationsManager reservationsManager
= new ReservationsManager();
/**
* The class that handles all our physical access to the database.
*/
private static DvdFileAccess database = null;
/**
* Constructor that assumes the Dvd database is in the current working
* directory.
*
* @throws FileNotFoundException if the database file cannot be found.
* @throws IOException if the database file cannot be written to.
*/
public DvdDatabase() throws FileNotFoundException, IOException {
// Note: This is the only place we are acknowledging that we are using
// a flat file instead of a commercial database. Create another Adapter
// & replace this one line, & the system can use a commercial database.
this(System.getProperty("user.dir"));
}
/**
* Constructor that takes the path of the Dvd database as a parameter.
*
* @param dbPath the path to the dvd_db directory
* @throws FileNotFoundException if the database file cannot be found.
* @throws IOException if the database file cannot be written to.
*/
public DvdDatabase(String dbPath)
throws FileNotFoundException, IOException {
// Note: This is the only place we are acknowledging that we are using
// a flat file instead of a commercial database. Create another Adapter
// & replace this one line, & the system can use a commercial database.
database = new DvdFileAccess(dbPath);
}
/**
* Adds a dvd to the database or inventory.
*
* @param dvd The Dvd item to add to inventory.
* @return Indicates the success/failure of the add operation.
* @throws IOException Indicates there is a problem accessing the database.
*/
public boolean addDVD(DVD dvd) throws IOException {
return database.addDvd(dvd);
}
/**
* Locates a Dvd using the upc identification number.
*
* @param upc The UPC of the Dvd to locate.
*
* @return The Dvd object which matches the upc or null if the Dvd does not
* exist.
* @throws IOException Indicates there is a problem accessing the data.
*/
public DVD getDVD(String upc) throws IOException {
return database.getDvd(upc);
}
/**
* Removes Dvd from inventory using the unique upc.
*
* @param upc The upc or key of the Dvd to be removed.
* @return true if the upc was found and the Dvd was removed.
* @throws IOException Indicates there is a problem accessing the data.
*/
public boolean removeDVD(String upc) throws IOException {
return database.removeDvd(upc);
}
/**
* Changes existing information of a Dvd item.
* Modifications can occur on any of the attributes of Dvd except UPC.
* The UPC is used to identify the Dvd to be modified.
*
* @param dvd The item in question
* @return Returns true if the Dvd was found and modified.
* @throws IOException Indicates there is a problem accessing the data.
*/
public boolean modifyDVD(DVD dvd) throws IOException {
return database.modifyDvd(dvd);
}
/**
* Gets the store's inventory.
* All of the Dvds in the system.
*
* @return A collection of all found Dvd's.
* @throws IOException Indicates there is a problem accessing the data.
*/
public List<DVD> getDVDs() throws IOException {
return database.getDvds();
}
/**
* A properly formatted <code>String</code> expressions returns all matching
* Dvd items. The <code>String</code> must be formatted as a regular
* expression.
*
* @param query formatted regular expression used as the search criteria.
* @return The list of Dvds that match the query. Can be an empty
* Collection.
* @throws IOException Indicates there is a problem accessing the data.
* be found.
* @throws PatternSyntaxException Indicates there is a syntax problen in
* the regular expression.
*/
public Collection<DVD> findDVD(String query)
throws IOException, PatternSyntaxException {
return database.find(query);
}
/**
* Lock the requested Dvd. This method blocks until the lock succeeds.
*
* @param upc The upc of the Dvd to reserve
* @return true if DVD could be reserved
* @throws InterruptedException Indicates the thread is interrupted.
*/
public boolean reserveDVD(String upc) throws InterruptedException {
return reservationsManager.reserveDvd(upc, this);
}
/**
* Unlock the requested record. Ignored if the caller does not have
* a current lock on the requested record.
*
* @param upc The upc of the Dvd to release
*/
public void releaseDVD(String upc) {
reservationsManager.releaseDvd(upc, this);
}
/**
* Locks or unlocks the entire database.
* @param locked true if the database is to be locked, false otherwise.
*/
public void setDatabaseLocked(boolean locked) {
if (database instanceof DvdFileAccess) {
((DvdFileAccess) database).setDatabaseLocked(locked);
}
}
}
|
package com.framgia.fsalon.screen.editstatusdialog;
import com.framgia.fsalon.data.model.Status;
import com.framgia.fsalon.data.source.BookingRepository;
import java.util.List;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.schedulers.Schedulers;
/**
* Listens to user actions from the UI ({@link EditStatusDialogFragment}), retrieves the data and
* updates the UI as required.
*/
public class EditStatusDialogPresenter implements EditStatusDialogContract.Presenter {
private static final String TAG = EditStatusDialogPresenter.class.getName();
private final EditStatusDialogContract.ViewModel mViewModel;
private int mBookingId;
private CompositeDisposable mCompositeDisposable = new CompositeDisposable();
private BookingRepository mRepository;
public EditStatusDialogPresenter(EditStatusDialogContract.ViewModel viewModel, int bookingId,
int statusId, BookingRepository repository) {
mViewModel = viewModel;
mBookingId = bookingId;
mRepository = repository;
makeStatus(statusId);
}
@Override
public void onStart() {
}
@Override
public void onStop() {
mCompositeDisposable.clear();
}
@Override
public void changeStatusBooking(int statusId) {
Disposable disposable = mRepository.changeStatusBooking(mBookingId, statusId)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new DisposableObserver<List<String>>() {
@Override
public void onNext(@NonNull List<String> list) {
String message = "";
for (String msg : list) {
message += msg + ",";
}
mViewModel.onChangeStatusSuccess(message);
}
@Override
public void onError(@NonNull Throwable e) {
mViewModel.onError(e.getMessage());
}
@Override
public void onComplete() {
}
});
mCompositeDisposable.add(disposable);
}
@Override
public void makeStatus(int statusIdCurrent) {
mViewModel.onGetStatusesSuccess(Status.getStatuses(statusIdCurrent));
}
}
|
import java.util.Scanner;
public class Mostrardo{
public static void main(String[]arg){
Scanner Lee=new Scanner(System.in);
int a,b,c=0,d=0;
System.out.print("Dame un numero: ");
a=Lee.nextInt();
System.out.print("Dame un numero mayor: ");
b=Lee.nextInt();
a+=1;
if(a<b){
do{
System.out.print(a+" ");
a++;
}while(a<b);
}
else{
System.out.println("LOS NUMEROS SON INCORRECTOS");
}
}
}
|
package com.esum.appframework.struts.action;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;
import com.esum.appframework.struts.actionform.UploadUtilForm;
public class UploadUtilAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{
return doService(mapping, form, request, response);
}
protected ActionForward doService(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
if (form != null && form instanceof UploadUtilForm) {
UploadUtilForm uploadForm = (UploadUtilForm)form;
String displayName = uploadForm.getDisplayName();
String uploadPath = uploadForm.getUploadPath();
FormFile formFile = uploadForm.getFileData();
String fileName= formFile.getFileName();
String contentType = formFile.getContentType();
int fileSize = formFile.getFileSize();
uploadPath.trim();
Character char_uploadPath = new Character(uploadPath.charAt(uploadPath.length() - 1));
String lastChar = char_uploadPath.toString();
if (!lastChar.equals(File.separator))
uploadPath += File.separator;
InputStream inputStream = formFile.getInputStream();
OutputStream outputStream = new FileOutputStream(uploadPath + fileName);
try {
int bytesRead = 0;
byte[] buffer = new byte[8192];
while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
}
catch (FileNotFoundException fnfe) {
return mapping.findForward("failure");
}
catch (IOException ioe) {
return mapping.findForward("failure");
}
finally {
outputStream.close();
inputStream.close();
}
return mapping.findForward("success");
}
return mapping.findForward("failure");
}
}
|
package com.eegeo.mapapi.services.mapscene;
import androidx.annotation.UiThread;
/**
* The data that defines a Mapscene, as created by the Map Designer or the Mapscene REST Service.
*/
public class Mapscene
{
/**
* The name of the Mapscene
*/
public final String name;
/**
* The hashed ID of the Mapscene, used when loading this Mapscene
*/
public final String shortlink;
/**
* The API Key to use for authenticating with the WRLD SDK. This is also used to link
* associated POI sets for use with the Searchbox Widget + POI Api.
*/
public final String apiKey;
/**
* Configuration of the initial start location of this Mapscene.
*/
public final MapsceneStartLocation startLocation;
/**
* Configuration of the data and themes to load for this Mapscene.
*/
public final MapsceneDataSources dataSources;
/**
* Optional configuration of the Searchbox Widget for this Mapscene.
*/
public final MapsceneSearchConfig searchConfig;
@UiThread
Mapscene(String name,
String shortLink,
String apiKey,
MapsceneStartLocation startLocation,
MapsceneDataSources dataSources,
MapsceneSearchConfig searchConfig)
{
this.name = name;
this.shortlink = shortLink;
this.apiKey = apiKey;
this.startLocation = startLocation;
this.dataSources = dataSources;
this.searchConfig = searchConfig;
}
}
|
package com.microservice.authserver.entity;
import java.io.Serializable;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import org.springframework.stereotype.Component;
@Component
@Entity
@Table(name = "role", schema = "profile")
public class Role implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
@ManyToMany(mappedBy = "roles")
private List<User> users;
@ManyToMany
private List<Privilege> privileges;
public Role() {
super();
}
public Role(Long id, String name, List<User> users, List<Privilege> privileges) {
super();
this.id = id;
this.name = name;
this.users = users;
this.privileges = privileges;
}
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 List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
public List<Privilege> getPrivileges() {
return privileges;
}
public void setPrivileges(List<Privilege> privileges) {
this.privileges = privileges;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
}
|
package extraction.output;
import extraction.logging.Logger;
public abstract class OutputHandler {
Logger logger;
public OutputHandler(Logger logger) {
this.logger = logger;
}
public abstract void output(OutputObject object);
public abstract void close();
}
|
package com.example.trialattemptone;
import android.app.AlarmManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.media.RingtoneManager;
import android.support.v4.app.NotificationCompat;
import com.example.trialattemptone.Creators.Alert;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class BootReceiver extends BroadcastReceiver {
SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
private NotificationManager notificationManager;
private PendingIntent alarmIntent;
public static String NOTIFICATION;
public static int alertID;
public static String NOTIFICATION_ID;
public static int alertHour;
public static String alertDateString;
public static Date alertDate;
public int notificationId;
@Override
public void onReceive(Context context, Intent intent) {
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
// Sets the receiver to enabled
notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification = intent.getParcelableExtra(NOTIFICATION);
notificationId = intent.getIntExtra(NOTIFICATION_ID, 0);
notificationManager.notify(notificationId, notification);
//Intent intent1 = new Intent(context, AlarmReceiver.class);
//
/*
// Set the alarm to start at approximately 2:00 p.m.
if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED"))
{
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.SECOND, 5);
Intent intent1 = new Intent(context, CourseDetailsScreen.class);
PendingIntent broadcast = PendingIntent.getBroadcast(context,100, intent1, PendingIntent.FLAG_UPDATE_CURRENT);
alarmMgr.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), alarmIntent);
}
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 14);
// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
AlarmManager.INTERVAL_DAY, alarmIntent);
// If the alarm has been set, cancel it.
if (alarmMgr!= null)
{
alarmMgr.cancel(alarmIntent);
}
*/
}
public void testingNotification(Context context, int alertActive)
{
ComponentName receiver = new ComponentName(context, BootReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);
NOTIFICATION_ID = "1";
if (alertActive == 0)
{
NotificationCompat.Builder builder = new NotificationCompat.Builder(context)
.setContentTitle("Content title")
.setContentText("Content text")
.setAutoCancel(true)
.setSmallIcon(R.drawable.ic_launcher_background)
.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
Intent intent = new Intent(context, MainActivity.class);
PendingIntent activity = PendingIntent.getActivity(context, notificationId, intent, PendingIntent.FLAG_CANCEL_CURRENT);
builder.setContentIntent(activity);
Notification notification = builder.build();
Intent notificationIntent = new Intent(context, BootReceiver.class);
notificationIntent.putExtra(BootReceiver.NOTIFICATION_ID, notificationId);
notificationIntent.putExtra(BootReceiver.NOTIFICATION, notification);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notificationId ,notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.SECOND, 5);
alarmManager.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent);
}
if (alertActive == 1)
{
Intent notificationIntent = new Intent(context, BootReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notificationId ,notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.cancel(pendingIntent);
}
}
public void scheduleNotification(Context context, Alert alert, String courseTitle)
{
// Sets the receiver to enabled
ComponentName receiver = new ComponentName(context, BootReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);
alertID = alert.getAlertID();
NOTIFICATION_ID = String.valueOf(alertID);
NOTIFICATION = alert.getTitle();
alertDateString = alert.getDate();
alertHour = alert.getHour();
int alertActive = alert.getActive();
int alerCourseID = alert.getCourseID();
try
{
alertDate = sdf.parse(alertDateString);
}catch (ParseException ex)
{
System.out.println(ex.getLocalizedMessage());
}
if (alertActive == 0)
{
NotificationCompat.Builder builder = new NotificationCompat.Builder(context)
.setContentTitle(courseTitle)
.setContentText(NOTIFICATION)
.setAutoCancel(true)
.setSmallIcon(R.drawable.ic_launcher_background)
.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
Intent intent = new Intent(context, MainActivity.class);
PendingIntent activity = PendingIntent.getActivity(context, notificationId, intent, PendingIntent.FLAG_CANCEL_CURRENT);
builder.setContentIntent(activity);
Notification notification = builder.build();
Intent notificationIntent = new Intent(context, BootReceiver.class);
notificationIntent.putExtra(BootReceiver.NOTIFICATION_ID, notificationId);
notificationIntent.putExtra(BootReceiver.NOTIFICATION, notification);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notificationId ,notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR, alertHour);
calendar.setTime(alertDate);
alarmManager.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent);
}
if (alertActive == 1)
{
Intent notificationIntent = new Intent(context, BootReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notificationId ,notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.cancel(pendingIntent);
}
}
}
|
package entrepot.bean.fait;
import entrepot.bean.contrat.IFait;
import entrepot.bean.dimension.Fournisseur;
import entrepot.bean.dimension.Produit;
import entrepot.bean.dimension.Temps;
/**
* @author tarik
*/
public class Fait_achat implements IFait{
private String code_fait_achat;
private String ref_produit;
private Produit produit;
private int id_temps;
private Temps temps;
private String code_fournisseur;
private Fournisseur fournisseur;
public Fait_achat(){}
public void achatMapper(String code_fait_achat, String ref_produit, String id_temps, String code_fournisseur){
this.setCode_fait_achat(code_fait_achat);
this.setRef_produit(ref_produit);
this.setId_temps(Integer.parseInt(id_temps));
this.setCode_fournisseur(code_fournisseur);
}
public String getCode_fait_achat() {
return code_fait_achat;
}
public void setCode_fait_achat(String code_fait_achat) {
this.code_fait_achat = code_fait_achat;
}
public String getRef_produit() {
return ref_produit;
}
public void setRef_produit(String ref_produit) {
this.ref_produit = ref_produit;
}
public int getId_temps() {
return id_temps;
}
public void setId_temps(int id_temps) {
this.id_temps = id_temps;
}
public String getCode_fournisseur() {
return code_fournisseur;
}
public void setCode_fournisseur(String code_fournisseur) {
this.code_fournisseur = code_fournisseur;
}
public Produit getProduit() {
return produit;
}
public void setProduit(Produit produit) {
this.produit = produit;
}
public Temps getTemps() {
return temps;
}
public void setTemps(Temps temps) {
this.temps = temps;
}
public Fournisseur getFournisseur() {
return fournisseur;
}
public void setFournisseur(Fournisseur fournisseur) {
this.fournisseur = fournisseur;
}
public boolean equals(Fait_achat fait_achat){
return this.getFournisseur().equals(fait_achat.getFournisseur())
&& this.getProduit().equals(fait_achat.getProduit())
&& this.getTemps().equals(fait_achat.getTemps());
}
}
|
package immutable;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CelestialCoordinatesTest {
@Test
private void testCelestialCoordinates() {
assertEquals("CelestialCoordinates{x=1, y=2, z=4}", new CelestialCoordinates(1, 2, 3).toString());
}
}
|
/**
*
*/
package com.hotel.master.user;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import com.hotel.master.customer.CustomerDTO;
import com.hotel.master.role.Role;
/**
* @author User
*
*/
public class UserInfo implements UserDetails, Serializable {
private Integer id;
private String username;
private String password;
private String firstName;
private String lastName;
private String email;
private Collection<Role> roles;
// private CustomerDTO customerDTO;
List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
/**
*
*/
private static final long serialVersionUID = 1L;
public UserInfo() {
}
/**
* @return the id
*/
public Integer getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(Integer id) {
this.id = id;
}
/**
* @return the email
*/
public String getEmail() {
return email;
}
/**
* @param email the email to set
*/
public void setEmail(String email) {
this.email = email;
}
/**
* @return the firstName
*/
public String getFirstName() {
return firstName;
}
/**
* @param firstName the firstName to set
*/
public void setFirstName(String firstName) {
this.firstName = firstName;
}
/**
* @return the lastName
*/
public String getLastName() {
return lastName;
}
/**
* @param lastName the lastName to set
*/
public void setLastName(String lastName) {
this.lastName = lastName;
}
/**
* @param username the username to set
*/
public void setUsername(String username) {
this.username = username;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return this.authorities;
}
@Override
public String getPassword() {
return this.password;
}
@Override
public String getUsername() {
return this.username;
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
/**
* @return the roles
*/
public Collection<Role> getRoles() {
return roles;
}
/**
* @param roles the roles to set
*/
public void setRoles(Collection<Role> roles) {
this.roles = roles;
}
}
|
package com.git.cloud.resmgt.common.service;
import java.util.List;
import com.git.cloud.common.exception.RollbackableBizException;
import com.git.cloud.common.service.IService;
import com.git.cloud.resmgt.common.model.po.CmVmPo;
import com.git.cloud.resmgt.common.model.vo.CmSnapshotVo;
import com.git.cloud.resmgt.common.model.vo.CmVmVo;
public interface ICmVmService extends IService{
public String updateVmDuId(CmVmVo cmvm)throws Exception;
public List<CmSnapshotVo> getCmSnapshotVoList(String vmId) throws Exception;
/**
* 根据服务器角色获取服务器角色下的虚机
*
* @Title: findCmVmByDuId
* @Description: TODO
* @field: @param duId
* @field: @return
* @field: @throws RollbackableBizException
* @return List<CmVmPo>
* @throws
*/
public List<CmVmPo> findCmVmByDuId(String duId) throws RollbackableBizException;
}
|
package com.nikita.recipiesapp.views.steps;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.design.widget.CollapsingToolbarLayout;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.Toolbar;
import com.facebook.drawee.view.SimpleDraweeView;
import com.nikita.recipiesapp.App;
import com.nikita.recipiesapp.R;
import com.nikita.recipiesapp.actions.AddSelectedRecipeToWidget;
import com.nikita.recipiesapp.actions.SelectStep;
import com.nikita.recipiesapp.common.AppState;
import com.nikita.recipiesapp.common.models.Recipe;
import com.nikita.recipiesapp.common.models.Step;
import com.nikita.recipiesapp.common.redux.Renderer;
/**
* An activity representing a list of Steps. This activity
* has different presentations for handset and tablet-size devices. On
* handsets, the activity presents a list of items, which when touched,
* lead to a {@link StepDetailActivity} representing
* item details. On tablets, the activity presents the list of items and
* item details side-by-side using two vertical panes.
*/
public class StepListActivity extends AppCompatActivity implements Renderer<AppState> {
private final StepListController stepListController = new StepListController(this::changeStep, v -> addToWidgetClick());
private boolean shouldOpenDetailsActivity = true;
private ActionBar actionBar;
private SimpleDraweeView headerImageView;
private Toolbar toolbar;
private CollapsingToolbarLayout collapsingToolbarLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.step_list_activity);
toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
actionBar = getSupportActionBar();
//noinspection ConstantConditions
actionBar.setDisplayHomeAsUpEnabled(true);
FloatingActionButton fab = findViewById(R.id.fab);
if (fab != null) {
fab.setOnClickListener(view -> StepDetailActivity.start(this));
}
headerImageView = findViewById(R.id.header_image);
collapsingToolbarLayout = findViewById(R.id.toolbar_layout);
RecyclerView recyclerView = findViewById(R.id.step_list);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setAdapter(stepListController.getAdapter());
shouldOpenDetailsActivity = findViewById(R.id.step_detail_container) == null;
App.appStore.subscribe(this);
}
@Override
public void render(@NonNull AppState appState) {
Recipe recipe = appState.selectedRecipe();
if (headerImageView != null) {
headerImageView.setImageURI(recipe.image);
}
if (collapsingToolbarLayout != null) {
collapsingToolbarLayout.setTitle(recipe.name);
}
toolbar.setTitle(recipe.name);
actionBar.setTitle(recipe.name);
stepListController.setData(recipe.ingredients, recipe.steps, appState.selectedStep());
}
private void changeStep(Step step) {
App.appStore.dispatch(new SelectStep(step));
if (shouldOpenDetailsActivity) {
StepDetailActivity.start(this);
}
}
private void addToWidgetClick() {
App.appStore.dispatch(new AddSelectedRecipeToWidget());
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.