code stringlengths 3 1.18M | language stringclasses 1 value |
|---|---|
package com.legendshop.core.exception;
public class ClientException extends RuntimeException {
private static final long serialVersionUID = 2848225058035251507L;
private String _$1;
public ClientException() {
}
public ClientException(String paramString1, String paramString2) {
super(paramString1);
this._$1 = paramString2;
}
public ClientException(String paramString) {
super(paramString);
this._$1 = null;
}
public ClientException(Throwable paramThrowable, String paramString) {
super(paramThrowable);
this._$1 = paramString;
}
public ClientException(Throwable paramThrowable, String paramString1,
String paramString2) {
super(paramString1, paramThrowable);
this._$1 = paramString2;
}
public String getErrorCode() {
return this._$1;
}
public void setErrorCode(String paramString) {
this._$1 = paramString;
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class LimitationException extends BaseException {
private static final long serialVersionUID = -4882836842833494358L;
public LimitationException(String paramString1, String paramString2) {
super(paramString1, paramString2, "401");
generateMessage(paramString1, paramString1);
}
public LimitationException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "401");
generateMessage(paramString1, paramString3);
}
public LimitationException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "401");
generateMessage(paramString,
ResourceBundleHelper.getString("limitation.hint"));
}
public LimitationException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("limitation.hint"), paramString2, paramString3);
}
public LimitationException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class BusinessException extends BaseException {
private static final long serialVersionUID = -1072822638462729389L;
public BusinessException(String paramString1, String paramString2) {
super(paramString1, paramString2, "998");
generateMessage(paramString1, paramString1);
}
public BusinessException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "998");
generateMessage(paramString1, paramString3);
}
public BusinessException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "998");
generateMessage(paramString,
ResourceBundleHelper.getString("BUSINESS_ERROR"));
}
public BusinessException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
public BusinessException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("BUSINESS_ERROR"), paramString2, paramString3);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class ApplicationException extends BaseException {
private static final long serialVersionUID = -8958497176157909350L;
public ApplicationException(String paramString1, String paramString2) {
super(paramString1, paramString2, "999");
generateMessage(paramString1, paramString1);
}
public ApplicationException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "999");
generateMessage(paramString1, paramString3);
}
public ApplicationException(Throwable paramThrowable, String paramString1,
String paramString2) {
super(paramThrowable, paramString1, paramString2, "999");
generateMessage(paramString1,
ResourceBundleHelper.getString("SYSTEM_ERROR"));
}
public ApplicationException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("SYSTEM_ERROR"), paramString2, paramString3);
}
public ApplicationException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class ConflictException extends BaseException {
private static final long serialVersionUID = 1134208068875011459L;
public ConflictException(String paramString1, String paramString2) {
super(paramString1, paramString2, "997");
generateMessage(paramString1, paramString1);
}
public ConflictException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "997");
generateMessage(paramString1, paramString3);
}
public ConflictException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "997");
generateMessage(paramString,
ResourceBundleHelper.getString("SYSTEM_ERROR"));
}
public ConflictException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("SYSTEM_ERROR"), paramString2, paramString3);
}
public ConflictException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class NotFoundException extends BaseException {
private static final long serialVersionUID = 1107139638880131340L;
public NotFoundException(String paramString1, String paramString2) {
super(paramString1, paramString2, "404");
generateMessage(paramString1, paramString1);
}
public NotFoundException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "404");
generateMessage(paramString1, paramString3);
}
public NotFoundException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "404");
generateMessage(paramString,
ResourceBundleHelper.getString("entity.missing"));
}
public NotFoundException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
public NotFoundException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("entity.missing"), paramString2, paramString3);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class InvalidFormatException extends BaseException {
private static final long serialVersionUID = 1474030746589727246L;
public InvalidFormatException(String paramString1, String paramString2) {
super(paramString1, paramString2, "604");
generateMessage(paramString1, paramString1);
}
public InvalidFormatException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "604");
generateMessage(paramString1, paramString3);
}
public InvalidFormatException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "604");
generateMessage(paramString,
ResourceBundleHelper.getString("invalid.format.hint"));
}
public InvalidFormatException(Throwable paramThrowable,
String paramString1, String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("invalid.format.hint"), paramString2, paramString3);
}
public InvalidFormatException(Throwable paramThrowable,
String paramString1, String paramString2, String paramString3,
String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
public abstract interface EntityCodes {
public static final String SYSTEM = "00";
public static final String SHOP = "10";
public static final String USER = "11";
public static final String PROD = "12";
public static final String NEWS = "13";
public static final String PUB = "14";
public static final String LINK = "15";
public static final String BASKET = "16";
public static final String SUB = "17";
public static final String LEAGUE = "18";
public static final String COMMENT = "19";
public static final String SORT = "20";
public static final String BRAND = "21";
public static final String LOGO = "22";
public static final String CASH = "23";
public static final String FILE = "24";
public static final String ADV = "25";
public static final String IMG = "26";
public static final String PAY = "27";
public static final String LOG = "28";
public static final String RIGHT = "29";
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.model.UserMessages;
public abstract class BaseException extends RuntimeException {
private static final long serialVersionUID = 2848225058035251507L;
protected String errorCode;
protected UserMessages userMessages;
public BaseException(String paramString1, String paramString2) {
this(paramString1, "00", paramString2);
}
public BaseException(String paramString1, String paramString2,
String paramString3) {
super(paramString1);
if ((paramString2 != null) && (paramString3 != null))
this.errorCode = (paramString2 + paramString3);
}
public BaseException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
super(paramString1, paramThrowable);
if ((paramString2 != null) && (paramString3 != null))
this.errorCode = (paramString2 + paramString3);
}
public BaseException(Throwable paramThrowable, String paramString1,
String paramString2) {
this(paramThrowable, paramString1, "00", paramString2);
}
public String getErrorCode() {
return this.errorCode;
}
public void setErrorCode(String paramString) {
this.errorCode = paramString;
}
public UserMessages getUserMessages() {
return this.userMessages;
}
public void setUserMessages(UserMessages paramUserMessages) {
this.userMessages = paramUserMessages;
}
protected void generateMessage(String paramString1, String paramString2) {
UserMessages localUserMessages = new UserMessages();
localUserMessages.setCode(this.errorCode);
localUserMessages.setTitle(paramString2);
localUserMessages.setDesc(paramString1);
setUserMessages(localUserMessages);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class PermissionException extends BaseException {
private static final long serialVersionUID = 1474030746589727246L;
public PermissionException(String paramString1, String paramString2) {
super(paramString1, paramString2, "402");
generateMessage(paramString1, paramString1);
}
public PermissionException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "402");
generateMessage(paramString1, paramString3);
}
public PermissionException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
public PermissionException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "402");
generateMessage(paramString,
ResourceBundleHelper.getString("no.permission.hint"));
}
public PermissionException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("no.permission.hint"), paramString2, paramString3);
}
}
| Java |
package com.legendshop.core.exception;
public abstract interface ErrorCodes {
public static final String NORMAL_STAUTS = "200";
public static final String SYSTEM_ERROR = "999";
public static final String BUSINESS_ERROR = "998";
public static final String CONFLICT_ERROR = "997";
public static final String INTERNAL_ERROR = "996";
public static final String ENTITY_NO_FOUND = "404";
public static final String LIMITATION_ERROR = "401";
public static final String UN_PERMISSION = "402";
public static final String CLOSED = "501";
public static final String AUDITING = "502";
public static final String TIME_OUT = "503";
public static final String SAVE_ERROR = "601";
public static final String UPDATE_ERROR = "602";
public static final String TOKEN_UNVALIDATE = "603";
public static final String SYSTEM_UNINSTALLED = "901";
public static final String MAX_INDEX_JPG_ERROR = "701";
public static final String PRODUCT_NO_FOUND = "702";
public static final String UN_AUTHORIZATION = "703";
public static final String UN_LOGIN = "704";
public static final String INVALID_FORMAT = "604";
public static final String NOT_ENOUGH_SCORE = "605";
public static final String NOT_ENOUGH_STOCKS = "606";
public static final String SCORE_TO_CASH_ERROR = "607";
public static final String NON_NULLABLE = "405";
public static final String SAVE_PRODUCT_ERROR = "406";
}
| Java |
package com.legendshop.core.exception;
import java.io.PrintStream;
import java.io.PrintWriter;
public class JCFException extends Exception {
private static final long serialVersionUID = -7425631664947561196L;
private Throwable _$2 = null;
private String _$1;
public static final String defaultCode = "1";
public static final String sameAsLocal = "-1";
public JCFException() {
this._$1 = "1";
}
public JCFException(String paramString1, String paramString2) {
super(paramString2);
this._$1 = paramString1;
if (paramString1 == null)
this._$1 = "1";
}
public JCFException(String paramString1, String paramString2,
Throwable paramThrowable) {
super(paramString2);
this._$2 = paramThrowable;
this._$1 = paramString1;
if (paramString1 == null)
this._$1 = "1";
}
public void printStackTrace() {
super.printStackTrace();
if (this._$2 != null) {
System.err.println("An exception has been caused by: ");
this._$2.printStackTrace();
}
}
public void printStackTrace(PrintStream paramPrintStream) {
super.printStackTrace(paramPrintStream);
if (this._$2 != null) {
paramPrintStream.println("An exception has been caused by: ");
this._$2.printStackTrace(paramPrintStream);
}
}
public void printStackTrace(PrintWriter paramPrintWriter) {
super.printStackTrace(paramPrintWriter);
if (this._$2 != null) {
paramPrintWriter.println("An exception has been caused by: ");
this._$2.printStackTrace(paramPrintWriter);
}
}
public String getErrorCode() {
return this._$1;
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class InternalException extends BaseException {
private static final long serialVersionUID = 1134208068875011459L;
public InternalException(String paramString1, String paramString2) {
super(paramString1, paramString2, "996");
generateMessage(paramString1, paramString1);
}
public InternalException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "996");
generateMessage(paramString1, paramString3);
}
public InternalException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "996");
generateMessage(paramString,
ResourceBundleHelper.getString("SYSTEM_ERROR"));
}
public InternalException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("SYSTEM_ERROR"), paramString2, paramString3);
}
public InternalException(Throwable paramThrowable, String paramString1,
String paramString2, String paramString3, String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
import com.legendshop.core.helper.ResourceBundleHelper;
public class AuthorizationException extends BaseException {
private static final long serialVersionUID = 3853365722199544447L;
public AuthorizationException(String paramString1, String paramString2) {
super(paramString1, paramString2, "703");
generateMessage(paramString1, paramString1);
}
public AuthorizationException(String paramString1, String paramString2,
String paramString3) {
super(paramString1, paramString2, "703");
generateMessage(paramString1, paramString3);
}
public AuthorizationException(Throwable paramThrowable, String paramString) {
super(paramThrowable, paramString, "703");
generateMessage(paramString,
ResourceBundleHelper.getString("no.login.hint"));
}
public AuthorizationException(Throwable paramThrowable,
String paramString1, String paramString2, String paramString3) {
this(paramThrowable, paramString1, ResourceBundleHelper
.getString("no.login.hint"), paramString2, paramString3);
}
public AuthorizationException(Throwable paramThrowable,
String paramString1, String paramString2, String paramString3,
String paramString4) {
super(paramString1, paramString3, paramString4);
generateMessage(paramString1, paramString2);
}
}
| Java |
package com.legendshop.core.exception;
import java.io.PrintStream;
import java.io.PrintWriter;
public class GoOnException extends Exception {
private static final long serialVersionUID = -6853904826035231555L;
private Throwable _$2 = null;
private String _$1;
public static final String defaultCode = "1";
public static final String sameAsLocal = "-1";
public GoOnException() {
this._$1 = "1";
}
public GoOnException(String paramString1, String paramString2) {
super(paramString2);
this._$1 = paramString1;
if (paramString1 == null)
this._$1 = "1";
}
public GoOnException(String paramString1, String paramString2,
Throwable paramThrowable) {
super(paramString2);
this._$2 = paramThrowable;
this._$1 = paramString1;
if (paramString1 == null)
this._$1 = "1";
}
public void printStackTrace() {
super.printStackTrace();
if (this._$2 != null) {
System.err.println("An exception has been caused by: ");
this._$2.printStackTrace();
}
}
public void printStackTrace(PrintStream paramPrintStream) {
super.printStackTrace(paramPrintStream);
if (this._$2 != null) {
paramPrintStream.println("An exception has been caused by: ");
this._$2.printStackTrace(paramPrintStream);
}
}
public void printStackTrace(PrintWriter paramPrintWriter) {
super.printStackTrace(paramPrintWriter);
if (this._$2 != null) {
paramPrintWriter.println("An exception has been caused by: ");
this._$2.printStackTrace(paramPrintWriter);
}
}
public String getErrorCode() {
return this._$1;
}
}
| Java |
package com.legendshop.core.photo;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.helper.PropertiesUtil;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
@SuppressWarnings("restriction")
public abstract class AbstractPhotoServlet extends HttpServlet {
private static final long serialVersionUID = -2064158852379937245L;
private static Logger _$1 = LoggerFactory
.getLogger(AbstractPhotoServlet.class);
protected static String NO_FILE_REPLACEMENT = "img/blank.jpg";
public synchronized void outLogo(File paramFile, String paramString,
OutputStream paramOutputStream, int paramInt1, int paramInt2)
throws IOException {
BufferedInputStream localBufferedInputStream = new BufferedInputStream(
new FileInputStream(paramFile), 4096);
BufferedImage localBufferedImage1 = ImageIO
.read(localBufferedInputStream);
int i = localBufferedImage1.getWidth(null);
int j = localBufferedImage1.getHeight(null);
int k;
int m;
if ((i > paramInt1) || (j > paramInt2)) {
if (i / paramInt1 >= j / paramInt2) {
k = paramInt1;
m = j * paramInt1 / i;
} else {
m = paramInt2;
k = i * paramInt2 / j;
}
} else {
k = i;
m = j;
}
BufferedImage localBufferedImage2 = new BufferedImage(k, m, 1);
localBufferedImage2.getGraphics().drawImage(localBufferedImage1, 0, 0,
k, m, null);
JPEGImageEncoder localJPEGImageEncoder1 = JPEGCodec
.createJPEGEncoder(paramOutputStream);
localJPEGImageEncoder1.encode(localBufferedImage2);
localBufferedInputStream.close();
paramOutputStream.flush();
paramOutputStream.close();
if (paramString != null) {
_$1.debug("generate small image url {}", paramString);
File localFile = new File(paramString.substring(0,
paramString.lastIndexOf("/")));
if (!localFile.exists())
localFile.mkdirs();
FileOutputStream localFileOutputStream = null;
try {
localFileOutputStream = new FileOutputStream(paramString);
JPEGImageEncoder localJPEGImageEncoder2 = JPEGCodec
.createJPEGEncoder(localFileOutputStream);
localJPEGImageEncoder2.encode(localBufferedImage2);
} catch (Exception localException) {
localException.printStackTrace();
} finally {
if (localFileOutputStream != null)
localFileOutputStream.close();
}
}
localBufferedImage1 = null;
}
protected void outputFile(HttpServletResponse paramHttpServletResponse,
File paramFile) throws IOException {
paramHttpServletResponse.setContentType("image/gif");
paramHttpServletResponse.setContentLength((int) paramFile.length());
ServletOutputStream localServletOutputStream = paramHttpServletResponse
.getOutputStream();
try {
dumpFile(paramFile, localServletOutputStream);
} catch (Exception localException) {
_$1.error("outputFile: {}", localException.getLocalizedMessage());
} finally {
localServletOutputStream.close();
}
}
protected void dumpFile(File paramFile, OutputStream paramOutputStream)
throws IOException {
byte[] arrayOfByte = new byte[4096];
BufferedInputStream localBufferedInputStream = null;
try {
localBufferedInputStream = new BufferedInputStream(
new FileInputStream(paramFile));
int i;
while ((i = localBufferedInputStream.read(arrayOfByte, 0, 4096)) != -1)
paramOutputStream.write(arrayOfByte, 0, i);
} catch (Exception localException) {
_$1.error("dumpFile: {}", localException.getLocalizedMessage());
} finally {
if (paramOutputStream != null)
paramOutputStream.close();
if (localBufferedInputStream != null)
localBufferedInputStream.close();
}
}
protected void noFileError(HttpServletResponse paramHttpServletResponse,
String paramString) {
PrintWriter localPrintWriter = null;
try {
paramHttpServletResponse.setContentType("text/html");
localPrintWriter = paramHttpServletResponse.getWriter();
localPrintWriter.println("<html>");
localPrintWriter.println("<br><br>Could not get file name ");
localPrintWriter.println("<br><br>© <a href=\"mailto:"
+ (String) PropertiesUtil.getObject(
ParameterEnum.SUPPORT_MAIL_LIST, String.class)
+ "\">LegendShop</a>");
localPrintWriter.println("</html>");
} catch (Exception localException) {
_$1.error("noFileError", localException);
} finally {
if (localPrintWriter != null) {
localPrintWriter.flush();
localPrintWriter.close();
}
}
_$1.error("there is no image file named {}", paramString);
}
}
| Java |
package com.legendshop.core.photo;
import java.io.File;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.legendshop.core.helper.PropertiesUtil;
public class ImagesServlet extends AbstractPhotoServlet {
private static final long serialVersionUID = -358253459242958398L;
Logger _$6 = LoggerFactory
.getLogger(ImagesServlet.class);
private String _$5;
private String _$4;
private int _$3 = 256;
private int _$2 = 188;
public void init() throws ServletException {
if (getServletConfig().getInitParameter("width") != null)
this._$3 = Integer.valueOf(
getServletConfig().getInitParameter("width")).intValue();
if (getServletConfig().getInitParameter("height") != null)
this._$2 = Integer.valueOf(
getServletConfig().getInitParameter("height")).intValue();
}
public void doGet(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse) throws IOException {
String str1 = paramHttpServletRequest.getPathInfo();
if (this._$5 == null)
this._$5 = PropertiesUtil.getSmallFilesAbsolutePath();
if (this._$4 == null)
this._$4 = PropertiesUtil.getBigFilesAbsolutePath();
String str2 = this._$5 + str1;
File localFile = new File(str2);
if (!localFile.isFile()) {
localFile = new File(this._$4 + str1);
if (!localFile.isFile())
localFile = new File(PropertiesUtil.getSystemRealPath()
+ NO_FILE_REPLACEMENT);
if (localFile.isFile())
outLogo(localFile, str2,
paramHttpServletResponse.getOutputStream(), this._$3,
this._$2);
else
noFileError(paramHttpServletResponse, str2);
} else {
outputFile(paramHttpServletResponse, localFile);
}
}
public void destroy() {
}
}
| Java |
package com.legendshop.core.photo;
import java.io.IOException;
import java.util.Enumeration;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
public class ResponseHeaderFilter implements Filter {
FilterConfig _$1;
public void doFilter(ServletRequest paramServletRequest,
ServletResponse paramServletResponse, FilterChain paramFilterChain)
throws IOException, ServletException {
HttpServletResponse localHttpServletResponse = (HttpServletResponse) paramServletResponse;
Enumeration<?> localEnumeration = this._$1.getInitParameterNames();
while (localEnumeration.hasMoreElements()) {
String str = (String) localEnumeration.nextElement();
localHttpServletResponse.setHeader(str,
this._$1.getInitParameter(str));
}
paramFilterChain
.doFilter(paramServletRequest, localHttpServletResponse);
}
public void init(FilterConfig paramFilterConfig) {
this._$1 = paramFilterConfig;
}
public void destroy() {
this._$1 = null;
}
}
| Java |
package com.legendshop.core.photo;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.helper.PropertiesUtil;
public class PhotoServlet extends AbstractPhotoServlet {
private static final long serialVersionUID = -7666260687183404653L;
Logger _$3 = LoggerFactory
.getLogger(PhotoServlet.class);
private String _$2;
public void init() throws ServletException {
this._$2 = PropertiesUtil.getBigFilesAbsolutePath();
}
public void doGet(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse)
throws ServletException, IOException {
String str1 = paramHttpServletRequest.getPathInfo();
String str2 = this._$2 + str1;
try {
File localFile = new File(str2);
if (!localFile.isFile())
localFile = new File(PropertiesUtil.getSystemRealPath()
+ NO_FILE_REPLACEMENT);
Object localObject1;
if (localFile.isFile()) {
localObject1 = null;
try {
paramHttpServletResponse.setContentType("image/gif");
paramHttpServletResponse.setContentLength((int) localFile
.length());
localObject1 = paramHttpServletResponse.getOutputStream();
dumpFile(localFile, (OutputStream) localObject1);
} catch (Exception ex) {
this._$3.error("doGet: {}", ex.getLocalizedMessage());
} finally {
if (localObject1 != null)
try {
((ServletOutputStream) localObject1).close();
} catch (Exception localException6) {
this._$3.error("clos servletoutputstream: {}",
localException6.getLocalizedMessage());
}
}
} else {
localObject1 = null;
try {
paramHttpServletResponse.setContentType("text/html");
localObject1 = paramHttpServletResponse.getWriter();
((PrintWriter) localObject1).println("<html>");
((PrintWriter) localObject1)
.println("<br><br>Could not get file name ");
((PrintWriter) localObject1)
.println("<br><br>© <a href=\"mailto:"
+ (String) PropertiesUtil.getObject(
ParameterEnum.SUPPORT_MAIL_LIST, String.class)
+ "\">LegendShop</a>");
((PrintWriter) localObject1).println("</html>");
} catch (Exception localException5) {
localException5.printStackTrace();
} finally {
if (localObject1 != null) {
((PrintWriter) localObject1).flush();
((PrintWriter) localObject1).close();
}
}
this._$3.error("there is no image file named ", str2);
}
} catch (Exception localException1) {
this._$3.error("PhotoServlet doGet: {}",
localException1.getLocalizedMessage());
}
}
public void destroy() {
System.out.println("PicServlet destroying");
}
}
| Java |
package com.legendshop.core;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.support.WebBindingInitializer;
import org.springframework.web.context.request.WebRequest;
public class MyBindingInitializer implements WebBindingInitializer {
public void initBinder(WebDataBinder paramWebDataBinder,
WebRequest paramWebRequest) {
SimpleDateFormat localSimpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd");
localSimpleDateFormat.setLenient(false);
paramWebDataBinder.registerCustomEditor(Date.class,
new CustomDateEditor(localSimpleDateFormat, true));
paramWebDataBinder.registerCustomEditor(String.class,
new StringTrimmerEditor(true));
}
}
| Java |
package com.legendshop.core.base;
import com.legendshop.core.UserManager;
import com.legendshop.core.constant.FunctionEnum;
import com.legendshop.core.constant.PagePathCalculator;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.dao.support.CriteriaQuery;
import com.legendshop.core.dao.support.PageSupport;
import com.legendshop.core.exception.BusinessException;
import com.legendshop.core.exception.PermissionException;
import com.legendshop.core.helper.FunctionUtil;
import com.legendshop.core.helper.PropertiesUtil;
import com.legendshop.model.UserMessages;
import com.legendshop.util.AppUtils;
import com.legendshop.util.BeanUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
public class BaseController extends MultiActionController {
@SuppressWarnings("unused")
private final String _$1 = "/theme";
@Autowired
protected LocaleResolver localeResolver;
public void copyProperties(Object paramObject1, Object paramObject2) {
BeanUtils.copyProperties(paramObject1, paramObject2);
}
public <T> T copyProperties(Class<T> paramClass, Object paramObject) {
return BeanUtils.copyProperties(paramClass, paramObject);
}
public void savePage(PageSupport paramPageSupport,
HttpServletRequest paramHttpServletRequest) {
paramHttpServletRequest.setAttribute("offset", new Integer(
paramPageSupport.getOffset() + 1));
paramHttpServletRequest.setAttribute("list",
paramPageSupport.getResultList());
paramHttpServletRequest.setAttribute("curPageNO",
Integer.valueOf(paramPageSupport.getCurPageNO()));
if (paramPageSupport.hasMutilPage())
paramHttpServletRequest.setAttribute("toolBar", paramPageSupport
.getToolBar(this.localeResolver
.resolveLocale(paramHttpServletRequest)));
}
@SuppressWarnings("unchecked")
public void saveMessage(HttpServletRequest paramHttpServletRequest,
String paramString) {
if (StringUtils.isNotBlank(paramString)) {
((List<String>) getOrCreateRequestAttribute(
paramHttpServletRequest, "springMessages", ArrayList.class))
.add(paramString);
}
}
@SuppressWarnings("unchecked")
protected static void saveError(HttpServletRequest paramHttpServletRequest,
String paramString) {
if (StringUtils.isNotBlank(paramString)) {
((List<String>) getOrCreateRequestAttribute(
paramHttpServletRequest, "springErrors", ArrayList.class))
.add(paramString);
}
}
protected String handleException(
HttpServletRequest paramHttpServletRequest,
UserMessages paramUserMessages) {
paramHttpServletRequest.setAttribute(UserMessages.MESSAGE_KEY,
paramUserMessages);
return "/common/error";
}
public static <T> Object getOrCreateRequestAttribute(
HttpServletRequest paramHttpServletRequest, String paramString,
Class<T> paramClass) {
Object localObject = paramHttpServletRequest.getAttribute(paramString);
if (localObject == null) {
try {
localObject = paramClass.newInstance();
} catch (Exception localException) {
ReflectionUtils.handleReflectionException(localException);
}
paramHttpServletRequest.setAttribute(paramString, localObject);
}
return localObject;
}
protected static String appendParamToURI(String paramString1,
String paramString2, String paramString3) {
String str = paramString1;
if (null != str) {
if (str.indexOf("?") < 0)
str = str + "?";
else
str = str + "&";
str = str + paramString2 + "=" + paramString3;
}
return str;
}
@SuppressWarnings("unused")
private static String _$1(Random paramRandom, int paramInt) {
StringBuilder localStringBuilder = new StringBuilder();
for (int i = 0; i < paramInt; i++) {
int j = paramRandom.nextInt(10);
localStringBuilder.append(String.valueOf(j));
}
return localStringBuilder.toString();
}
protected Set<MultipartFile> getFileSet(HttpServletRequest req) {
MultipartHttpServletRequest multReq = (MultipartHttpServletRequest) req;
LinkedHashSet<MultipartFile> fileSet = new LinkedHashSet<MultipartFile>();
Iterator<String> fileNames = multReq.getFileNames();
while (fileNames.hasNext()) {
String fileName = fileNames.next();
MultipartFile file = multReq.getFile(fileName);
if (file.getOriginalFilename().length() > 0)
fileSet.add(file);
}
return fileSet;
}
protected CriteriaQuery hasAllDataFunction(
CriteriaQuery paramCriteriaQuery,
HttpServletRequest paramHttpServletRequest, String paramString) {
if (FunctionUtil.haveViewAllDataFunction(paramHttpServletRequest)) {
if (!AppUtils.isBlank(paramString))
paramCriteriaQuery.like("userName",
"%" + StringUtils.trim(paramString) + "%");
} else {
String str = UserManager.getUsername(paramHttpServletRequest
.getSession());
if (str == null)
throw new PermissionException(paramString
+ " did not logon yet!", "29");
paramCriteriaQuery.eq("userName", str);
}
return paramCriteriaQuery;
}
protected CriteriaQuery hasAllDataAndOperationFunction(
CriteriaQuery paramCriteriaQuery,
HttpServletRequest paramHttpServletRequest, String paramString) {
if (UserManager.hasFunction(paramHttpServletRequest.getSession(),
new String[] {FunctionEnum.FUNCTION_VIEW_ALL_DATA.value(),
FunctionEnum.FUNCTION_F_OPERATOR.value(),
FunctionEnum.FUNCTION_F_ADMIN.value(),
FunctionEnum.FUNCTION_F_SYSTEM.value() })) {
if (!AppUtils.isBlank(paramString))
paramCriteriaQuery.like("userName",
"%" + StringUtils.trim(paramString) + "%");
} else {
String str = UserManager.getUsername(paramHttpServletRequest
.getSession());
if (str == null)
throw new PermissionException(paramString
+ " did not logon yet!", "29");
paramCriteriaQuery.eq("userName", str);
}
return paramCriteriaQuery;
}
protected void hasAllDataFunction(CriteriaQuery paramCriteriaQuery,
HttpServletRequest paramHttpServletRequest, String paramString1,
String paramString2) {
if (FunctionUtil.haveViewAllDataFunction(paramHttpServletRequest)) {
if (AppUtils.isNotBlank(paramString2))
paramCriteriaQuery.like(paramString1,
"%" + StringUtils.trim(paramString2) + "%");
} else {
String str = UserManager.getUsername(paramHttpServletRequest
.getSession());
if (str == null)
throw new PermissionException(paramString2
+ " did not logon yet!", "29");
paramCriteriaQuery.eq(paramString1, str);
}
}
protected String checkPrivilege(HttpServletRequest paramHttpServletRequest,
String paramString1, String paramString2) {
String str = checkLogin(paramHttpServletRequest, paramString1);
if (str != null)
return str;
if ((!FunctionUtil.haveViewAllDataFunction(paramHttpServletRequest))
&& (!paramString1.equals(paramString2))) {
UserMessages localUserMessages = new UserMessages("401",
"Access Deny", " can not edit this object belongs to "
+ paramString2);
str = handleException(paramHttpServletRequest, localUserMessages);
}
return str;
}
protected String checkLogin(HttpServletRequest paramHttpServletRequest,
String paramString) {
if (paramString == null)
return PagePathCalculator.calculateTilesPath("login.", "default");
return null;
}
protected void checkNullable(String paramString, Object paramObject) {
if (paramObject == null)
throw new BusinessException(paramString + " is non nullable", "00");
}
protected String getShopName(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse) {
String str = (String) getSessionAttribute(paramHttpServletRequest,
"shopName");
if (!AppUtils.isBlank(str))
return str;
Cookie[] arrayOfCookie1 = paramHttpServletRequest.getCookies();
if (arrayOfCookie1 != null)
for (Cookie localCookie : arrayOfCookie1) {
if (!"shopName".equalsIgnoreCase(localCookie.getName()))
continue;
str = localCookie.getValue();
}
if (AppUtils.isBlank(str)) {
str = (String) PropertiesUtil.getObject(ParameterEnum.DEFAULT_SHOP,
String.class);
setShopName(paramHttpServletRequest, paramHttpServletResponse, str);
}
return str;
}
protected void setShopName(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, String paramString) {
setSessionAttribute(paramHttpServletRequest, "shopName", paramString);
Cookie localCookie = new Cookie("shopName", paramString);
localCookie.setMaxAge(31536000);
localCookie.setPath("/");
paramHttpServletResponse.addCookie(localCookie);
}
protected Object getSessionAttribute(
HttpServletRequest paramHttpServletRequest, String paramString) {
Object localObject = null;
HttpSession localHttpSession = paramHttpServletRequest
.getSession(false);
if (localHttpSession != null)
localObject = localHttpSession.getAttribute(paramString);
return localObject;
}
protected void setSessionAttribute(
HttpServletRequest paramHttpServletRequest, String paramString,
Object paramObject) {
HttpSession localHttpSession = paramHttpServletRequest
.getSession(false);
if (localHttpSession != null)
localHttpSession.setAttribute(paramString, paramObject);
}
}
| Java |
package com.legendshop.core.base;
public abstract interface Controller {
}
| Java |
package com.legendshop.core.base;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public abstract interface AdminController<E, K> extends Controller {
public abstract String query(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, String paramString,
E paramE);
public abstract String save(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, E paramE);
public abstract String delete(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, K paramK);
public abstract String load(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse);
public abstract String update(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, K paramK);
}
| Java |
package com.legendshop.core.dao.impl;
import com.legendshop.core.cache.CacheObjectImpl;
import com.legendshop.core.dao.BaseDao;
import com.legendshop.core.dao.support.CriteriaQuery;
import com.legendshop.core.dao.support.HqlQuery;
import com.legendshop.core.dao.support.PageSupport;
import com.legendshop.core.dao.support.SimpleQbc;
import com.legendshop.core.dao.support.SqlQuery;
import com.legendshop.core.page.PagerUtil;
import com.legendshop.util.AppUtils;
import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.transform.Transformers;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.util.Assert;
@SuppressWarnings("rawtypes")
public class BaseDaoImpl extends CacheObjectImpl implements BaseDao {
private boolean cache = false;
private HibernateTemplate hibernateTemplate;
public boolean isCache() {
return this.cache;
}
public void setCache(boolean cache) {
this.cache = cache;
}
public HibernateTemplate getHibernateTemplate() {
return this.hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
public <T> T get(Class<T> entityClass, Serializable id) {
return getHibernateTemplate().get(entityClass, id);
}
public <T> T getByLockMode(Class<T> entityClass, Serializable id,
LockMode lockMode) {
return getHibernateTemplate().get(entityClass, id, lockMode);
}
public <T> T load(Class<T> entityClass, Serializable id) {
return getHibernateTemplate().load(entityClass, id);
}
public <T> T loadByLockMode(Class<T> entityClass, Serializable id,
LockMode lockMode) {
return getHibernateTemplate().load(entityClass, id, lockMode);
}
public <T> List<T> getAll(Class<T> entityClass) {
return getHibernateTemplate().loadAll(entityClass);
}
@SuppressWarnings("unchecked")
public <T> List<T> getAll(Class<T> entityClass, String propertyName,
boolean asc) {
Assert.hasText(propertyName);
if (asc)
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(entityClass).addOrder(
Order.asc(propertyName)));
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(entityClass).addOrder(
Order.desc(propertyName)));
}
public Serializable save(Object entity) {
return getHibernateTemplate().save(entity);
}
public void saveOrUpdate(Object entity) {
getHibernateTemplate().saveOrUpdate(entity);
}
public void saveOrUpdateAll(Collection<?> entities) {
getHibernateTemplate().saveOrUpdateAll(entities);
}
public void update(Object entity) {
getHibernateTemplate().update(entity);
}
public void delete(Object entity) {
getHibernateTemplate().delete(entity);
}
public boolean delete(Class<?> entityClass, Serializable id) {
Object localObject = getHibernateTemplate().get(entityClass, id);
if (localObject != null) {
delete(localObject);
return true;
}
return false;
}
public <T> void deleteById(Class<T> entityClass, Serializable id) {
Object localObject = get(entityClass, id);
if (localObject != null)
delete(localObject);
}
public void deleteAll(Collection<?> entities) {
getHibernateTemplate().deleteAll(entities);
}
public void flush() {
getHibernateTemplate().flush();
}
public void clear() {
getHibernateTemplate().clear();
}
public List find(String queryString, Object[] values) {
Assert.hasText(queryString);
return getHibernateTemplate().find(queryString, values);
}
public List findByHQL(String queryString) {
Assert.hasText(queryString);
return getHibernateTemplate().find(queryString);
}
public List findByHQL(String queryString, Object[] values) {
return getHibernateTemplate().find(queryString, values);
}
public <T> T findUniqueBy(final String str, final Class<T> entityClass,
final Object[] values) {
return getHibernateTemplate().execute(new HibernateCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInHibernate(Session session)
throws HibernateException, SQLException {
Query localQuery = session.createQuery(str);
if (AppUtils.isNotBlank(values))
for (int i = 0; i < values.length; i++)
localQuery.setParameter(i, values[i]);
if (BaseDaoImpl.this.isCache())
localQuery.setCacheable(true);
return (T) localQuery.uniqueResult();
}
});
}
public List findByHQLLimit(final String queryString, final int firstResult,
final int maxResults, final Object[] values) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
Query localQuery = session.createQuery(queryString);
if (AppUtils.isNotBlank(values))
for (int i = 0; i < values.length; i++)
localQuery.setParameter(i, values[i]);
if (BaseDaoImpl.this.isCache())
localQuery.setCacheable(true);
localQuery.setFirstResult(firstResult);
localQuery.setMaxResults(maxResults);
return localQuery.list();
}
});
}
public <T> T findUniqueByHQLLimit(final String queryString,
final Class<T> entityClass, final int firstResult,
final int maxResults, final Object[] values) {
return getHibernateTemplate().execute(new HibernateCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInHibernate(Session session)
throws HibernateException, SQLException {
Query localQuery = session.createQuery(queryString);
if (AppUtils.isNotBlank(values))
for (int i = 0; i < values.length; i++)
localQuery.setParameter(i, values[i]);
if (BaseDaoImpl.this.isCache())
localQuery.setCacheable(true);
localQuery.setFirstResult(firstResult);
localQuery.setMaxResults(maxResults);
return (T) localQuery.uniqueResult();
}
});
}
public List findByHQLLimit(final String queryString, final int firstResult,
final int maxResults) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
Query localQuery = session.createQuery(queryString);
if (BaseDaoImpl.this.cache)
localQuery.setCacheable(true);
localQuery.setFirstResult(firstResult);
localQuery.setMaxResults(maxResults);
return localQuery.list();
}
});
}
public List findBySQL(final String queryString) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery localSQLQuery = session.createSQLQuery(queryString);
if (BaseDaoImpl.this.isCache())
localSQLQuery.setCacheable(true);
return localSQLQuery.list();
}
});
}
public List findBySQL(final String queryString, final Object[] values,
final Type[] types) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery sqlQuery = session.createSQLQuery(queryString);
if (BaseDaoImpl.this.cache)
sqlQuery.setCacheable(true);
sqlQuery.setParameters(values, types);
return sqlQuery.list();
}
});
}
public List findByExample(Object entity) {
return getHibernateTemplate().findByExample(entity);
}
public Object merge(Object entity) {
return getHibernateTemplate().merge(entity);
}
public void attachClean(Object entity) {
getHibernateTemplate().lock(entity, LockMode.NONE);
}
public List find(final SimpleQbc simpleQbc, final boolean paged) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = simpleQbc.getDetachedCriteria()
.getExecutableCriteria(session);
if (BaseDaoImpl.this.cache)
criteria.setCacheable(true);
if (paged) {
long l = ((Number) criteria.setProjection(
Projections.rowCount()).uniqueResult()).longValue();
criteria.setProjection(null);
int i = PagerUtil.getCurPageNO(simpleQbc.getCurPage());
int j = PagerUtil.getOffset(l, i, simpleQbc.getPageSize());
criteria.setFirstResult(j);
criteria.setMaxResults(simpleQbc.getPageSize());
}
return criteria.list();
}
});
}
public void executeBySql(final String queryString) {
getHibernateTemplate().execute(new HibernateCallback<Object>() {
@Override
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
try {
@SuppressWarnings("deprecation")
Connection conn = session.connection();
PreparedStatement prepStat = conn
.prepareStatement(queryString);
prepStat.execute();
prepStat.close();
session.flush();
session.clear();
return null;
} catch (RuntimeException rex) {
rex.printStackTrace();
return rex;
}
}
});
}
public String executeByProcedure(final String queryString,
final String[] params) {
return getHibernateTemplate().execute(new HibernateCallback<String>() {
@Override
public String doInHibernate(Session session)
throws HibernateException, SQLException {
try {
@SuppressWarnings("deprecation")
Connection conn = session.connection();
CallableStatement localCallableStatement = conn
.prepareCall(queryString);
localCallableStatement.registerOutParameter(1, 12);
int i = 2;
for (String str : params) {
localCallableStatement.setString(i, str);
i++;
}
localCallableStatement.executeUpdate();
String str = localCallableStatement.getString(1);
if (localCallableStatement != null)
localCallableStatement.close();
return str;
} catch (RuntimeException rex) {
rex.printStackTrace();
return rex.getLocalizedMessage();
}
}
});
}
public Integer exeByHQL(final String queryString, final Object[] values,
final Type[] types) {
return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
@Override
public Integer doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(queryString);
if (BaseDaoImpl.this.cache)
query.setCacheable(true);
query.setParameters(values, types);
return Integer.valueOf(query.executeUpdate());
}
});
}
public Integer exeByHQL(final String queryString, final Object[] values) {
return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
@Override
public Integer doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(queryString);
if (BaseDaoImpl.this.cache)
query.setCacheable(true);
if (AppUtils.isNotBlank(values))
for (int i = 0; i < values.length; i++)
query.setParameter(i, values[i]);
return Integer.valueOf(query.executeUpdate());
}
});
}
public PageSupport find(final HqlQuery hqlQuery) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
Query localQuery1 = session.createQuery(hqlQuery
.getQueryString());
if (BaseDaoImpl.this.isCache())
localQuery1.setCacheable(true);
Query localQuery2 = session.createQuery(hqlQuery
.getAllCountString());
List<Object> localList = hqlQuery.getParams();
if (!AppUtils.isBlank(localList)) {
for (int i = 0; i < localList.size(); i++) {
localQuery1.setParameter(i, localList.get(i));
localQuery2.setParameter(i, localList.get(i));
}
} else {
Object[] arrayOfObject = hqlQuery.getParam();
Type[] arrayOfType = hqlQuery.getTypes();
if (!AppUtils.isBlank(arrayOfObject))
if (!AppUtils.isBlank(arrayOfType)) {
localQuery1.setParameters(hqlQuery.getParam(),
hqlQuery.getTypes());
localQuery2.setParameters(hqlQuery.getParam(),
hqlQuery.getTypes());
} else {
for (int j = 0; j < arrayOfObject.length; j++) {
localQuery1.setParameter(j,
arrayOfObject[j]);
localQuery2.setParameter(j,
arrayOfObject[j]);
}
}
}
long l = ((Number) localQuery2.uniqueResult()).longValue();
int j = PagerUtil.getCurPageNO(hqlQuery.getCurPage());
int k = PagerUtil.getOffset(l, j, hqlQuery.getPageSize());
localQuery1.setFirstResult(k);
localQuery1.setMaxResults(hqlQuery.getPageSize());
return new PageSupport(localQuery1.list(), hqlQuery
.getMyaction(), k, j, l, hqlQuery.getPageSize());
}
});
}
public PageSupport find(final SqlQuery paramSqlQuery) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery sqlQuery = session.createSQLQuery(paramSqlQuery
.getQueryString());
if (AppUtils.isNotBlank(paramSqlQuery.getEntityClass())) {
Iterator<String> iter = paramSqlQuery.getEntityClass()
.keySet().iterator();
while (iter.hasNext()) {
String key = iter.next();
sqlQuery.setResultTransformer(Transformers
.aliasToBean(paramSqlQuery.getEntityClass()
.get(key)));
}
}
if (BaseDaoImpl.this.cache)
sqlQuery.setCacheable(true);
SQLQuery sqlCount = session.createSQLQuery(paramSqlQuery
.getAllCountString());
List<?> params = paramSqlQuery.getParams();
if (!AppUtils.isBlank(params)) {
for (int i = 0; i < params.size(); i++) {
sqlQuery.setParameter(i, params.get(i));
sqlCount.setParameter(i, params.get(i));
}
} else {
Object[] values = paramSqlQuery.getParam();
Type[] types = paramSqlQuery.getTypes();
if (!AppUtils.isBlank(values)) {
if (!AppUtils.isBlank(types)) {
sqlQuery.setParameters(values, types);
sqlCount.setParameters(values, types);
} else {
for (int j = 0; j < values.length; j++) {
sqlQuery.setParameter(j, values[j]);
sqlCount.setParameter(j, values[j]);
}
}
}
}
long l = ((Number) sqlCount.uniqueResult()).longValue();
int j = PagerUtil.getCurPageNO(paramSqlQuery.getCurPage());
int k = PagerUtil.getOffset(l, j,
paramSqlQuery.getPageSize());
sqlQuery.setFirstResult(k);
sqlQuery.setMaxResults(paramSqlQuery.getPageSize());
return new PageSupport(sqlQuery.list(), paramSqlQuery
.getMyaction(), k, j, l, paramSqlQuery.getPageSize());
}
});
}
public PageSupport findMap(final SqlQuery sqlQuery) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery localSQLQuery1 = session.createSQLQuery(sqlQuery
.getQueryString());
localSQLQuery1
.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
if (BaseDaoImpl.this.isCache())
localSQLQuery1.setCacheable(true);
SQLQuery localSQLQuery2 = session.createSQLQuery(sqlQuery
.getAllCountString());
List<?> localList = sqlQuery.getParams();
if (!AppUtils.isBlank(localList)) {
for (int i = 0; i < localList.size(); i++) {
localSQLQuery1.setParameter(i, localList.get(i));
localSQLQuery2.setParameter(i, localList.get(i));
}
} else {
Object[] arrayOfObject = sqlQuery.getParam();
Type[] arrayOfType = sqlQuery.getTypes();
if (!AppUtils.isBlank(arrayOfObject))
if (!AppUtils.isBlank(arrayOfType)) {
localSQLQuery1.setParameters(
sqlQuery.getParam(), sqlQuery.getTypes());
localSQLQuery2.setParameters(
sqlQuery.getParam(), sqlQuery.getTypes());
} else {
for (int j = 0; j < arrayOfObject.length; j++) {
localSQLQuery1.setParameter(j,
arrayOfObject[j]);
localSQLQuery2.setParameter(j,
arrayOfObject[j]);
}
}
}
long l = ((Number) localSQLQuery2.uniqueResult())
.longValue();
int j = PagerUtil.getCurPageNO(sqlQuery.getCurPage());
int k = PagerUtil.getOffset(l, j, sqlQuery.getPageSize());
localSQLQuery1.setFirstResult(k);
localSQLQuery1.setMaxResults(sqlQuery.getPageSize());
return new PageSupport(localSQLQuery1.list(), sqlQuery
.getMyaction(), k, j, l, sqlQuery.getPageSize());
}
});
}
public List findListByHQL(final HqlQuery paramHqlQuery,
final int firstResult, final int maxResults) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(paramHqlQuery
.getQueryString());
if (BaseDaoImpl.this.cache)
query.setCacheable(true);
if ((!AppUtils.isBlank(paramHqlQuery.getParam()))
&& (!AppUtils.isBlank(paramHqlQuery.getTypes())))
query.setParameters(paramHqlQuery.getParam(),
paramHqlQuery.getTypes());
query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
return query.list();
}
});
}
public PageSupport findBySql(final HqlQuery paramHqlQuery) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery localSQLQuery1 = session
.createSQLQuery(paramHqlQuery.getQueryString());
if (BaseDaoImpl.this.isCache())
localSQLQuery1.setCacheable(true);
SQLQuery localSQLQuery2 = session
.createSQLQuery(paramHqlQuery.getAllCountString());
if ((!AppUtils.isBlank(paramHqlQuery.getParam()))
&& (!AppUtils.isBlank(paramHqlQuery.getTypes()))) {
localSQLQuery1.setParameters(paramHqlQuery.getParam(),
paramHqlQuery.getTypes());
localSQLQuery2.setParameters(paramHqlQuery.getParam(),
paramHqlQuery.getTypes());
}
long l = ((Number) localSQLQuery2.list().get(0))
.longValue();
int i = PagerUtil.getCurPageNO(paramHqlQuery.getCurPage());
int j = PagerUtil.getOffset(l, i,
paramHqlQuery.getPageSize());
localSQLQuery1.setFirstResult(j);
localSQLQuery1.setMaxResults(paramHqlQuery.getPageSize());
return new PageSupport(localSQLQuery1.list(), paramHqlQuery
.getMyaction(), j, i, l, paramHqlQuery.getPageSize());
}
});
}
public List findListBySql(final HqlQuery hqlQuery, final int firstResult,
final int maxResults) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
SQLQuery localSQLQuery = session.createSQLQuery(hqlQuery
.getQueryString());
if (BaseDaoImpl.this.cache)
localSQLQuery.setCacheable(true);
if ((!AppUtils.isBlank(hqlQuery.getParam()))
&& (!AppUtils.isBlank(hqlQuery.getTypes()))) {
localSQLQuery.setParameters(hqlQuery.getParam(),
hqlQuery.getTypes());
}
localSQLQuery.setFirstResult(firstResult);
localSQLQuery.setMaxResults(maxResults);
return localSQLQuery.list();
}
});
}
public PageSupport find(final CriteriaQuery criteriaQuery,
final boolean paged) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria criteria = criteriaQuery.getDetachedCriteria()
.getExecutableCriteria(session);
if (BaseDaoImpl.this.cache)
criteria.setCacheable(true);
long l = ((Number) criteria.setProjection(
Projections.rowCount()).uniqueResult()).longValue();
criteria.setProjection(null);
int i = PagerUtil.getCurPageNO(criteriaQuery.getCurPage());
int j = PagerUtil.getOffset(l, i,
criteriaQuery.getPageSize());
if (paged) {
criteria.setFirstResult(j);
criteria.setMaxResults(criteriaQuery.getPageSize());
}
return new PageSupport(criteria.list(), criteriaQuery
.getMyaction(), j, i, l, criteriaQuery.getPageSize());
}
});
}
public PageSupport find(final CriteriaQuery criteriaQuery) {
return getHibernateTemplate().execute(
new HibernateCallback<PageSupport>() {
@Override
public PageSupport doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria localCriteria = criteriaQuery
.getDetachedCriteria().getExecutableCriteria(session);
if (BaseDaoImpl.this.cache)
localCriteria.setCacheable(true);
Projection localProjection = Projections.rowCount();
long l = ((Number) localCriteria.setProjection(
localProjection).uniqueResult()).longValue();
localCriteria.setProjection(null);
int i = PagerUtil.getCurPageNO(criteriaQuery.getCurPage());
int j = PagerUtil.getOffset(l, i,
criteriaQuery.getPageSize());
localCriteria.setFirstResult(j);
localCriteria.setMaxResults(criteriaQuery.getPageSize());
return new PageSupport(localCriteria.list(), criteriaQuery
.getMyaction(), j, i, l, criteriaQuery.getPageSize());
}
});
}
public List findListByCriteria(final CriteriaQuery criteriaQuery,
final int firstResult, final int maxResults) {
return getHibernateTemplate().execute(new HibernateCallback<List>() {
@Override
public List doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria localCriteria = criteriaQuery.getDetachedCriteria()
.getExecutableCriteria(session);
if (BaseDaoImpl.this.cache)
localCriteria.setCacheable(true);
localCriteria.setFirstResult(firstResult);
localCriteria.setMaxResults(maxResults);
return localCriteria.list();
}
});
}
}
| Java |
package com.legendshop.core.dao.support;
import java.io.Serializable;
import java.util.ArrayList;
public class Page implements Serializable {
private static final long serialVersionUID = -5623840070668936608L;
private static int _$5 = 20;
private int _$4 = _$5;
private long _$3;
private Object _$2;
private long _$1;
public Page() {
this(0L, 0L, _$5, new ArrayList<Object>());
}
public Page(long paramLong1, long paramLong2, int paramInt,
Object paramObject) {
this._$4 = paramInt;
this._$3 = paramLong1;
this._$1 = paramLong2;
this._$2 = paramObject;
}
public long getTotalCount() {
return this._$1;
}
public long getTotalPageCount() {
if (this._$1 % this._$4 == 0L)
return this._$1 / this._$4;
return this._$1 / this._$4 + 1L;
}
public int getPageSize() {
return this._$4;
}
public Object getResult() {
return this._$2;
}
public long getCurrentPageNo() {
return this._$3 / this._$4 + 1L;
}
public boolean hasNextPage() {
return getCurrentPageNo() < getTotalPageCount() - 1L;
}
public boolean hasPreviousPage() {
return getCurrentPageNo() > 1L;
}
protected static int getStartOfPage(int paramInt) {
return getStartOfPage(paramInt, _$5);
}
public static int getStartOfPage(int paramInt1, int paramInt2) {
return (paramInt1 - 1) * paramInt2;
}
}
| Java |
package com.legendshop.core.dao.support;
import com.legendshop.core.page.PagerUtil;
import java.io.Serializable;
import java.util.List;
import java.util.Locale;
public class PageSupport implements Serializable {
private static final long serialVersionUID = -7058040526668991342L;
private int curPageNO;
private int offset;
private int pageSize;
private long total = 0L;
@SuppressWarnings("unused")
private String toolBar;
private String myaction;
private List<?> resultList = null;
public PageSupport() {
}
public PageSupport(List<?> resultList, String myaction, int offset,
int curPageNO, long total, int pageSize) {
this.curPageNO = curPageNO;
this.offset = offset;
this.myaction = myaction;
this.resultList = resultList;
this.total = total;
this.pageSize = pageSize;
}
public List<?> getResultList() {
return this.resultList;
}
public void setResultList(List<?> resultList) {
this.resultList = resultList;
}
public String getToolBar() {
return PagerUtil.getBar(this.myaction, this.total, this.curPageNO,
this.pageSize);
}
public String getToolBar(Locale locale) {
return getToolBar(locale, "PageProvider");
}
public String getToolBar(Locale locale, String beanName) {
return PagerUtil.getLocaleBar(locale, this.myaction, this.total,
this.curPageNO, this.pageSize, beanName);
}
public void setToolBar(String toolBar) {
this.toolBar = toolBar;
}
public int getOffset() {
return this.offset;
}
public void setOffset(int offset) {
this.offset = offset;
}
public int getCurPageNO() {
return this.curPageNO;
}
public void setCurPageNO(int curPageNO) {
this.curPageNO = curPageNO;
}
public long getTotal() {
return this.total;
}
public int getPageSize() {
return this.pageSize;
}
public boolean hasMutilPage() {
return this.total > this.pageSize;
}
public String getMyaction() {
return this.myaction;
}
public void setMyaction(String myaction) {
this.myaction = myaction;
}
}
| Java |
package com.legendshop.core.dao.support;
import com.legendshop.util.AppUtils;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.hibernate.type.Type;
public class SqlQuery implements Serializable {
private static final long serialVersionUID = -8185266081416916752L;
private String curPage = null;
private int pageSize = 12;
private String myaction = "javascript:pager";
private Map<String, Class<?>> entityClass;
private String queryString;
private String allCountString;
private Object[] param;
private Type[] types;
private List<Object> params = new ArrayList<Object>();
public SqlQuery(String queryString, String allCountString,
List<Object> params) {
this.queryString = queryString;
this.allCountString = allCountString;
this.params = params;
}
public SqlQuery(int pageSize, String curPage) {
this.pageSize = pageSize;
this.curPage = curPage;
this.myaction = "javascript:pager";
}
public SqlQuery(String myaction) {
this.myaction = myaction;
}
public String getCurPage() {
return this.curPage;
}
public void setCurPage(String curPage) {
this.curPage = curPage;
}
public String getMyaction() {
return this.myaction;
}
public void setMyaction(String myaction) {
this.myaction = myaction;
}
public int getPageSize() {
return this.pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public String getQueryString() {
return this.queryString;
}
public void setQueryString(String queryString) {
this.queryString = queryString;
}
public int hashCode() {
int i = 1;
i = 31 * i + (this.curPage == null ? 0
: this.curPage.hashCode());
i = 31 * i + (this.myaction == null ? 0
: this.myaction.hashCode());
i = 31 * i + this.pageSize;
i = 31 * i + (this.queryString == null ? 0
: this.queryString.hashCode());
return i;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
SqlQuery localSqlQuery = (SqlQuery) obj;
if (this.curPage == null) {
if (localSqlQuery.curPage != null)
return false;
} else if (!this.curPage.equals(localSqlQuery.curPage))
return false;
if (this.myaction == null) {
if (localSqlQuery.myaction != null)
return false;
} else if (!this.myaction.equals(localSqlQuery.myaction))
return false;
if (this.pageSize != localSqlQuery.pageSize)
return false;
if (this.queryString == null) {
if (localSqlQuery.queryString != null)
return false;
} else if (!this.queryString.equals(localSqlQuery.queryString))
return false;
return true;
}
public String getAllCountString() {
return this.allCountString;
}
public void setAllCountString(String allCountString) {
this.allCountString = allCountString;
}
public List<Object> getParams() {
return this.params;
}
public boolean addParam(Object param) {
return this.params.add(param);
}
public void setParams(List<Object> params) {
this.params = params;
}
public Object[] getParam() {
return this.param;
}
public void setParam(Object[] param) {
this.param = param;
}
public Type[] getTypes() {
return this.types;
}
public void setTypes(Type[] types) {
this.types = types;
}
public void addParams(Object param) {
if (!AppUtils.isBlank(param))
this.params.add(param);
}
public Map<String, Class<?>> getEntityClass() {
return this.entityClass;
}
public void setEntityClass(Map<String, Class<?>> entityClass) {
this.entityClass = entityClass;
}
public void addEntityClass(String entity, Class<?> clazz) {
if (this.entityClass == null)
this.entityClass = new HashMap<String, Class<?>>();
this.entityClass.put(entity, clazz);
}
}
| Java |
package com.legendshop.core.dao.support;
import com.legendshop.util.AppUtils;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.type.Type;
public class HqlQuery implements Serializable {
private static final long serialVersionUID = 6728373478527870071L;
private String _$9 = null;
private int _$8 = 10;
private String _$7 = "";
private String _$6;
private String _$5;
private String _$4;
private Object[] _$3;
private Type[] _$2;
private List<Object> _$1 = new ArrayList<Object>();
public HqlQuery(String paramString1, String paramString2,
Object[] paramArrayOfObject) {
this._$5 = paramString1;
this._$4 = paramString2;
this._$3 = paramArrayOfObject;
}
public HqlQuery(String paramString) {
this._$7 = paramString;
}
public HqlQuery() {
this("javascript:pager");
}
public HqlQuery(int paramInt, String paramString1, String paramString2) {
this._$8 = paramInt;
this._$9 = paramString1;
this._$7 = paramString2;
}
public HqlQuery(int paramInt, String paramString) {
this._$8 = paramInt;
this._$9 = paramString;
this._$7 = "javascript:pager";
}
public Object[] getParam() {
return this._$3;
}
public HqlQuery(String paramString1, String paramString2,
String paramString3, List<Object> paramList) {
this._$7 = paramString1;
this._$5 = paramString2;
this._$4 = paramString3;
this._$1 = paramList;
}
public HqlQuery(String paramString1, String paramString2,
List<Object> paramList) {
this._$5 = paramString1;
this._$4 = paramString2;
this._$1 = paramList;
}
public HqlQuery(String paramString1, String paramString2,
String paramString3, Object[] paramArrayOfObject,
Type[] paramArrayOfType) {
this._$7 = paramString1;
this._$5 = paramString2;
this._$4 = paramString3;
this._$3 = paramArrayOfObject;
this._$2 = paramArrayOfType;
}
public HqlQuery(String paramString, Object[] paramArrayOfObject,
Type[] paramArrayOfType) {
this._$5 = paramString;
this._$3 = paramArrayOfObject;
this._$2 = paramArrayOfType;
}
public void setParam(Object[] paramArrayOfObject) {
this._$3 = paramArrayOfObject;
}
public String getCurPage() {
return this._$9;
}
public void setCurPage(String paramString) {
this._$9 = paramString;
}
public String getMyaction() {
return this._$7;
}
public void setMyaction(String paramString) {
this._$7 = paramString;
}
public String getMyform() {
return this._$6;
}
public void setMyform(String paramString) {
this._$6 = paramString;
}
public int getPageSize() {
return this._$8;
}
public void setPageSize(int paramInt) {
this._$8 = paramInt;
}
public String getQueryString() {
return this._$5;
}
public void setQueryString(String paramString) {
this._$5 = paramString;
}
public Type[] getTypes() {
return this._$2;
}
public void setTypes(Type[] paramArrayOfType) {
this._$2 = paramArrayOfType;
}
public int hashCode() {
int i = 1;
i = 31 * i + (this._$9 == null ? 0
: this._$9.hashCode());
i = 31 * i + (this._$7 == null ? 0
: this._$7.hashCode());
i = 31 * i + (this._$6 == null ? 0
: this._$6.hashCode());
i = 31 * i + this._$8;
i = 31 * i + (this._$5 == null ? 0
: this._$5.hashCode());
return i;
}
public boolean equals(Object paramObject) {
if (this == paramObject)
return true;
if (paramObject == null)
return false;
if (getClass() != paramObject.getClass())
return false;
HqlQuery localHqlQuery = (HqlQuery) paramObject;
if (this._$9 == null) {
if (localHqlQuery._$9 != null)
return false;
} else if (!this._$9.equals(localHqlQuery._$9))
return false;
if (this._$7 == null) {
if (localHqlQuery._$7 != null)
return false;
} else if (!this._$7.equals(localHqlQuery._$7))
return false;
if (this._$6 == null) {
if (localHqlQuery._$6 != null)
return false;
} else if (!this._$6.equals(localHqlQuery._$6))
return false;
if (this._$8 != localHqlQuery._$8)
return false;
if (this._$5 == null) {
if (localHqlQuery._$5 != null)
return false;
} else if (!this._$5.equals(localHqlQuery._$5))
return false;
return true;
}
public String getAllCountString() {
return this._$4;
}
public void setAllCountString(String paramString) {
this._$4 = paramString;
}
public List<Object> getParams() {
return this._$1;
}
public void setParams(List<Object> paramList) {
this._$1 = paramList;
}
public void addParams(Object paramObject) {
if (!AppUtils.isBlank(paramObject))
this._$1.add(paramObject);
}
}
| Java |
package com.legendshop.core.dao.support;
import com.legendshop.util.AppUtils;
import java.io.Serializable;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
public class SimpleQbc implements Serializable {
private static final long serialVersionUID = 9267579412443536L;
private String curPage = null;
private int pageSize = 15;
private CriterionList criterionList;
private DetachedCriteria detachedCriteria;
public SimpleQbc() {
}
public SimpleQbc(Class<?> clazz) {
this.criterionList = new CriterionList();
this.detachedCriteria = DetachedCriteria.forClass(clazz);
}
public SimpleQbc(Class<?> clazz, String paramString) {
this.curPage = paramString;
this.criterionList = new CriterionList();
this.detachedCriteria = DetachedCriteria.forClass(clazz);
}
public CriterionList getCriterionList() {
return this.criterionList;
}
public void setCriterionList(CriterionList criterionList) {
this.criterionList = criterionList;
}
public String getCurPage() {
return this.curPage;
}
public void setCurPage(String curPage) {
this.curPage = curPage;
}
public DetachedCriteria getDetachedCriteria() {
return this.detachedCriteria;
}
public void setDetachedCriteria(DetachedCriteria detachedCriteria) {
this.detachedCriteria = detachedCriteria;
}
public void add(Criterion paramCriterion) {
this.detachedCriteria.add(paramCriterion);
}
public void add() {
for (int i = 0; i < getCriterionList().size(); i++)
add(getCriterionList().getParas(i));
}
public void createAlias(String paramString) {
this.detachedCriteria.createCriteria(paramString);
}
public void createAlias(String paramString1, String paramString2) {
this.detachedCriteria.createCriteria(paramString1, paramString2);
}
public Criterion and(SimpleQbc paramSimpleQbc, int paramInt1, int paramInt2) {
return Restrictions.and(
paramSimpleQbc.getCriterionList().getParas(paramInt1),
paramSimpleQbc.getCriterionList().getParas(paramInt2));
}
public Criterion and(Criterion paramCriterion, SimpleQbc paramSimpleQbc,
int paramInt) {
return Restrictions.and(paramCriterion, paramSimpleQbc
.getCriterionList().getParas(paramInt));
}
public Criterion and(Criterion paramCriterion1, Criterion paramCriterion2) {
return Restrictions.and(paramCriterion1, paramCriterion2);
}
public Criterion or(SimpleQbc paramSimpleQbc, int paramInt1, int paramInt2) {
return Restrictions.or(
paramSimpleQbc.getCriterionList().getParas(paramInt1),
paramSimpleQbc.getCriterionList().getParas(paramInt2));
}
public Criterion or(Criterion paramCriterion, SimpleQbc paramSimpleQbc,
int paramInt) {
return Restrictions.or(paramCriterion, paramSimpleQbc
.getCriterionList().getParas(paramInt));
}
public void or(Criterion paramCriterion1, Criterion paramCriterion2) {
this.detachedCriteria.add(Restrictions.or(paramCriterion1,
paramCriterion2));
}
public void addOrder(String paramString1, String paramString2) {
if ("asc".equals(paramString1))
this.detachedCriteria.addOrder(Order.asc(paramString2));
else
this.detachedCriteria.addOrder(Order.desc(paramString2));
}
public void eq(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.eq(paramString, paramObject));
}
public void isnull(String paramString) {
this.criterionList.addPara(Restrictions.isNull(paramString));
}
public void isNotNull(String paramString) {
this.criterionList.addPara(Restrictions.isNotNull(paramString));
}
public void not(Criterion paramCriterion) {
this.criterionList.addPara(Restrictions.not(paramCriterion));
}
public void notEq(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.or(
Restrictions.gt(paramString, paramObject),
Restrictions.lt(paramString, paramObject)));
}
public void like(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.like(paramString, paramObject));
}
public void gt(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.gt(paramString, paramObject));
}
public void lt(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.lt(paramString, paramObject));
}
public void le(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.le(paramString, paramObject));
}
public void ge(String paramString, Object paramObject) {
this.criterionList.addPara(Restrictions.ge(paramString, paramObject));
}
public void ilike(String paramString, Object[] paramArrayOfObject) {
this.criterionList.addPara(Restrictions.in(paramString,
paramArrayOfObject));
}
public void between(String paramString, Object paramObject1,
Object paramObject2) {
Criterion localObject = null;
if ((!AppUtils.isBlank(paramObject1))
&& (!AppUtils.isBlank(paramObject2)))
localObject = Restrictions.between(paramString, paramObject1,
paramObject2);
else if (!AppUtils.isBlank(paramObject1))
localObject = Restrictions.ge(paramString, paramObject1);
else if (!AppUtils.isBlank(paramObject2))
localObject = Restrictions.le(paramString, paramObject2);
this.criterionList.add(localObject);
}
public int getPageSize() {
return this.pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public String toString() {
return super.toString();
}
}
| Java |
package com.legendshop.core.dao.support;
import java.util.ArrayList;
import org.hibernate.criterion.Criterion;
public class CriterionList extends ArrayList<Criterion> {
private static final long serialVersionUID = 8369292865546912044L;
public final Criterion getParas(int paramInt) {
return (Criterion) super.get(paramInt);
}
public final void addPara(int paramInt, Criterion paramCriterion) {
super.add(paramInt, paramCriterion);
}
public final void addPara(Criterion paramCriterion) {
super.add(paramCriterion);
}
public final int indexofPara(Criterion paramCriterion) {
return super.indexOf(paramCriterion);
}
public final void removePara(int paramInt) {
super.remove(paramInt);
}
}
| Java |
package com.legendshop.core.dao.support;
import com.legendshop.util.AppUtils;
import java.io.Serializable;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
public class CriteriaQuery implements Serializable {
private static final long serialVersionUID = -1464383406564081554L;
private String _$6 = null;
private int _$5 = 16;
private String _$4;
private String _$3;
private CriterionList _$2;
private DetachedCriteria _$1;
public CriteriaQuery() {
}
public CriteriaQuery(Class<?> paramClass) {
this._$2 = new CriterionList();
this._$1 = DetachedCriteria.forClass(paramClass);
}
public CriteriaQuery(Class<?> paramClass, String paramString1,
String paramString2, String paramString3) {
this._$4 = paramString2;
this._$3 = paramString3;
this._$6 = paramString1;
this._$2 = new CriterionList();
this._$1 = DetachedCriteria.forClass(paramClass);
}
public CriteriaQuery(Class<?> paramClass, String paramString1,
String paramString2) {
this._$4 = paramString2;
this._$6 = paramString1;
this._$2 = new CriterionList();
this._$1 = DetachedCriteria.forClass(paramClass);
}
public CriteriaQuery(Class<?> paramClass, String paramString) {
this(paramClass, paramString, "javascript:pager");
}
public CriterionList getCriterionList() {
return this._$2;
}
public void setCriterionList(CriterionList paramCriterionList) {
this._$2 = paramCriterionList;
}
public String getCurPage() {
return this._$6;
}
public void setCurPage(String paramString) {
this._$6 = paramString;
}
public DetachedCriteria getDetachedCriteria() {
return this._$1;
}
public void setDetachedCriteria(DetachedCriteria paramDetachedCriteria) {
this._$1 = paramDetachedCriteria;
}
public void add(Criterion paramCriterion) {
this._$1.add(paramCriterion);
}
public void add() {
for (int i = 0; i < getCriterionList().size(); i++)
add(getCriterionList().getParas(i));
}
public void createAlias(String paramString) {
this._$1.createCriteria(paramString);
}
public void createAlias(String paramString1, String paramString2) {
this._$1.createCriteria(paramString1, paramString2);
}
public Criterion and(CriteriaQuery paramCriteriaQuery, int paramInt1,
int paramInt2) {
return Restrictions.and(
paramCriteriaQuery.getCriterionList().getParas(paramInt1),
paramCriteriaQuery.getCriterionList().getParas(paramInt2));
}
public Criterion and(Criterion paramCriterion,
CriteriaQuery paramCriteriaQuery, int paramInt) {
return Restrictions.and(paramCriterion, paramCriteriaQuery
.getCriterionList().getParas(paramInt));
}
public Criterion and(Criterion paramCriterion1, Criterion paramCriterion2) {
return Restrictions.and(paramCriterion1, paramCriterion2);
}
public Criterion or(CriteriaQuery paramCriteriaQuery, int paramInt1,
int paramInt2) {
return Restrictions.or(
paramCriteriaQuery.getCriterionList().getParas(paramInt1),
paramCriteriaQuery.getCriterionList().getParas(paramInt2));
}
public Criterion or(Criterion paramCriterion,
CriteriaQuery paramCriteriaQuery, int paramInt) {
return Restrictions.or(paramCriterion, paramCriteriaQuery
.getCriterionList().getParas(paramInt));
}
public void or(Criterion paramCriterion1, Criterion paramCriterion2) {
this._$1.add(Restrictions.or(paramCriterion1, paramCriterion2));
}
public void addOrder(String paramString1, String paramString2) {
if ("asc".equals(paramString1))
this._$1.addOrder(Order.asc(paramString2));
else
this._$1.addOrder(Order.desc(paramString2));
}
public void eq(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.eq(paramString, paramObject));
}
public void notEq(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.or(
Restrictions.gt(paramString, paramObject),
Restrictions.lt(paramString, paramObject)));
}
public void like(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.like(paramString, paramObject));
}
public void gt(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.gt(paramString, paramObject));
}
public void lt(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.lt(paramString, paramObject));
}
public void le(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.le(paramString, paramObject));
}
public void ge(String paramString, Object paramObject) {
if (AppUtils.isNotBlank(paramObject))
this._$2.addPara(Restrictions.ge(paramString, paramObject));
}
public void ilike(String paramString, Object[] paramArrayOfObject) {
if (AppUtils.isNotBlank(paramArrayOfObject))
this._$2.addPara(Restrictions.in(paramString, paramArrayOfObject));
}
public void between(String paramString, Object paramObject1,
Object paramObject2) {
Criterion localObject = null;
if ((AppUtils.isNotBlank(paramObject1))
&& (AppUtils.isNotBlank(paramObject2)))
localObject = Restrictions.between(paramString, paramObject1,
paramObject2);
else if (AppUtils.isNotBlank(paramObject1))
localObject = Restrictions.ge(paramString, paramObject1);
else if (AppUtils.isNotBlank(paramObject2))
localObject = Restrictions.le(paramString, paramObject2);
this._$2.add(localObject);
}
public int getPageSize() {
return this._$5;
}
public void setPageSize(int paramInt) {
this._$5 = paramInt;
}
public String getMyaction() {
return this._$4;
}
public void setMyaction(String paramString) {
this._$4 = paramString;
}
public String getMyform() {
return this._$3;
}
public void setMyform(String paramString) {
this._$3 = paramString;
}
public int hashCode() {
int i = 1;
i = 31 * i + (this._$6 == null ? 0
: this._$6.hashCode());
i = 31 * i + (this._$4 == null ? 0
: this._$4.hashCode());
i = 31 * i + (this._$3 == null ? 0
: this._$3.hashCode());
i = 31 * i + this._$5;
return i;
}
public boolean equals(Object paramObject) {
if (this == paramObject)
return true;
if (paramObject == null)
return false;
if (getClass() != paramObject.getClass())
return false;
CriteriaQuery localCriteriaQuery = (CriteriaQuery) paramObject;
if (this._$6 == null) {
if (localCriteriaQuery._$6 != null)
return false;
} else if (!this._$6.equals(localCriteriaQuery._$6))
return false;
if (this._$4 == null) {
if (localCriteriaQuery._$4 != null)
return false;
} else if (!this._$4.equals(localCriteriaQuery._$4))
return false;
if (this._$3 == null) {
if (localCriteriaQuery._$3 != null)
return false;
} else if (!this._$3.equals(localCriteriaQuery._$3))
return false;
return this._$5 == localCriteriaQuery._$5;
}
public String toString() {
return super.toString();
}
}
| Java |
package com.legendshop.core.dao;
import com.legendshop.core.cache.CacheObject;
import com.legendshop.core.dao.support.CriteriaQuery;
import com.legendshop.core.dao.support.HqlQuery;
import com.legendshop.core.dao.support.PageSupport;
import com.legendshop.core.dao.support.SimpleQbc;
import com.legendshop.core.dao.support.SqlQuery;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import org.hibernate.LockMode;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateTemplate;
@SuppressWarnings("rawtypes")
public abstract interface BaseDao extends CacheObject {
public abstract boolean isCache();
public abstract void setCache(boolean paramBoolean);
public abstract <T> T get(Class<T> paramClass,
Serializable paramSerializable);
public abstract <T> T getByLockMode(Class<T> paramClass,
Serializable paramSerializable, LockMode paramLockMode);
public abstract <T> T load(Class<T> paramClass,
Serializable paramSerializable);
public abstract <T> T loadByLockMode(Class<T> paramClass,
Serializable paramSerializable, LockMode paramLockMode);
public abstract <T> List<T> getAll(Class<T> paramClass);
public abstract <T> List<T> getAll(Class<T> paramClass, String paramString,
boolean paramBoolean);
public abstract Serializable save(Object paramObject);
public abstract void saveOrUpdate(Object paramObject);
public abstract void saveOrUpdateAll(Collection<?> paramCollection);
public abstract void update(Object paramObject);
public abstract void delete(Object paramObject);
public abstract boolean delete(Class<?> paramClass,
Serializable paramSerializable);
public abstract <T> void deleteById(Class<T> paramClass,
Serializable paramSerializable);
public abstract void deleteAll(Collection<?> paramCollection);
public abstract void flush();
public abstract void clear();
public abstract List find(String paramString, Object[] paramArrayOfObject);
public abstract List findByHQL(String paramString);
public abstract List findByHQL(String paramString,
Object[] paramArrayOfObject);
public abstract <T> T findUniqueBy(String paramString, Class<T> paramClass,
Object[] paramArrayOfObject);
public abstract List findByHQLLimit(String paramString, int paramInt1,
int paramInt2, Object[] paramArrayOfObject);
public abstract <T> T findUniqueByHQLLimit(String paramString,
Class<T> paramClass, int paramInt1, int paramInt2,
Object[] paramArrayOfObject);
public abstract List findByHQLLimit(String paramString, int paramInt1,
int paramInt2);
public abstract List findBySQL(String paramString);
public abstract List findBySQL(String paramString,
Object[] paramArrayOfObject, Type[] paramArrayOfType);
public abstract List findByExample(Object paramObject);
public abstract Object merge(Object paramObject);
public abstract void attachClean(Object paramObject);
public abstract List find(SimpleQbc paramSimpleQbc, boolean paramBoolean);
public abstract void executeBySql(String paramString);
public abstract String executeByProcedure(String paramString,
String[] paramArrayOfString);
public abstract Integer exeByHQL(String paramString,
Object[] paramArrayOfObject, Type[] paramArrayOfType);
public abstract Integer exeByHQL(String paramString,
Object[] paramArrayOfObject);
public abstract HibernateTemplate getHibernateTemplate();
public abstract void setHibernateTemplate(
HibernateTemplate paramHibernateTemplate);
public abstract PageSupport find(HqlQuery paramHqlQuery);
public abstract PageSupport find(SqlQuery paramSqlQuery);
public abstract PageSupport findMap(SqlQuery paramSqlQuery);
public abstract List findListByHQL(HqlQuery paramHqlQuery, int paramInt1,
int paramInt2);
public abstract PageSupport findBySql(HqlQuery paramHqlQuery);
public abstract List findListBySql(HqlQuery paramHqlQuery, int paramInt1,
int paramInt2);
public abstract PageSupport find(CriteriaQuery paramCriteriaQuery,
boolean paramBoolean);
public abstract PageSupport find(CriteriaQuery paramCriteriaQuery);
public abstract List findListByCriteria(CriteriaQuery paramCriteriaQuery,
int paramInt1, int paramInt2);
}
| Java |
package com.legendshop.core.helper;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.List;
import java.util.Random;
import org.apache.commons.io.FileUtils;
import org.apache.oro.text.perl.Perl5Util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.exception.InvalidFormatException;
import com.legendshop.util.AppUtils;
public class FileProcessor {
private static Logger _$1 = LoggerFactory.getLogger(FileProcessor.class);
public static void main(String[] paramArrayOfString) {
}
@SuppressWarnings("unused")
private void _$1(String paramString) {
System.out.println(paramString);
}
public static String getFileSuffixName(String paramString) {
try {
if (paramString != null)
return paramString.substring(paramString.lastIndexOf(".") + 1);
} catch (Exception localException) {
}
return null;
}
public static int deleteFile(String paramString) {
try {
File localFile1 = new File(paramString);
if (localFile1.exists()) {
String str1 = PropertiesUtil.getBackupFilesAbsolutePath();
if (AppUtils.isNotBlank(str1)) {
String str2 = PropertiesUtil.getBigFilesAbsolutePath();
if ((AppUtils.isNotBlank(str2))
&& (paramString.indexOf(str2) > -1)) {
String str3 = paramString;
str3 = str3.replace(str2, str1);
File localFile2 = new File(str3);
FileUtils.copyFile(localFile1, localFile2);
}
}
localFile1.delete();
return 0;
}
_$1.warn("没有该文件：{}", paramString);
return 1;
} catch (Exception localException) {
_$1.warn("删除文件 {} 失败", paramString);
}
return 2;
}
public static void deleteDirectory(File paramFile) {
if (!paramFile.exists())
return;
if (paramFile.isFile()) {
paramFile.delete();
return;
}
File[] arrayOfFile = paramFile.listFiles();
for (int i = 0; i < arrayOfFile.length; i++)
deleteDirectory(arrayOfFile[i]);
paramFile.delete();
}
public static String addNameBeforeSuffix(String paramString1,
String paramString2) {
try {
if ((paramString1 != null) && (paramString2 != null)
&& (paramString1.indexOf(".") != -1))
paramString1 = paramString1.substring(0,
paramString1.lastIndexOf("."))
+ paramString2
+ paramString1.substring(paramString1.lastIndexOf("."));
} catch (Exception localException) {
}
return paramString1;
}
public static String uploadFile(File paramFile, String paramString1,
String paramString2, boolean paramBoolean1, boolean paramBoolean2) {
String str = null;
try {
str = uploadFile(new FileInputStream(paramFile), paramString1,
paramString2, paramFile.getName(), paramBoolean1, paramBoolean2);
} catch (Exception localException) {
return null;
}
return str;
}
public static String uploadFile(InputStream paramInputStream,
String paramString1, String paramString2, String paramString3,
boolean paramBoolean1, boolean paramBoolean2) {
FileOutputStream localFileOutputStream = null;
try {
String str1 = paramString3.substring(paramString3.lastIndexOf("."))
.toLowerCase();
if (paramBoolean1)
paramString3 = paramString2 + System.currentTimeMillis()
+ randomNumeric(new Random(), 6) + str1;
File localFile1 = new File(paramString1);
if (!localFile1.exists())
localFile1.mkdirs();
File localFile2 = new File(paramString1 + File.separator
+ paramString3);
if ((localFile2.exists()) && (paramBoolean1)) {
paramString3 = System.currentTimeMillis() + "_" + paramString3;
localFile2 = new File(paramString1 + File.separator
+ paramString3);
} else if ((localFile2.exists()) && (!paramBoolean2)) {
String str2 = paramString3;
return str2;
}
localFileOutputStream = new FileOutputStream(localFile2);
int i = 0;
byte[] arrayOfByte = new byte[8192];
while ((i = paramInputStream.read(arrayOfByte)) > 0)
localFileOutputStream.write(arrayOfByte, 0, i);
} catch (Exception localException2) {
return null;
} finally {
try {
localFileOutputStream.close();
paramInputStream.close();
} catch (Exception localException5) {
}
}
return paramString3;
}
public static String randomNumeric(Random paramRandom, int paramInt) {
StringBuilder localStringBuilder = new StringBuilder();
for (int i = 0; i < paramInt; i++) {
int j = paramRandom.nextInt(10);
localStringBuilder.append(String.valueOf(j));
}
return localStringBuilder.toString();
}
public static boolean copyFile(File paramFile1, File paramFile2) {
try {
FileInputStream localFileInputStream = new FileInputStream(
paramFile1);
FileOutputStream localFileOutputStream = new FileOutputStream(
paramFile2);
int i = 0;
byte[] arrayOfByte = new byte[8192];
while ((i = localFileInputStream.read(arrayOfByte)) > 0)
localFileOutputStream.write(arrayOfByte, 0, i);
localFileOutputStream.close();
localFileInputStream.close();
} catch (Exception localException) {
return false;
}
return true;
}
public static String writeFile(String paramString1, String paramString2,
String paramString3, boolean paramBoolean1, boolean paramBoolean2,
boolean paramBoolean3) {
try {
File localFile1 = new File(paramString2);
if (!localFile1.exists())
localFile1.mkdirs();
File localFile2 = new File(paramString2 + File.separator
+ paramString3);
if ((localFile2.exists()) && (paramBoolean1)) {
paramString3 = System.currentTimeMillis() + "_" + paramString3;
localFile2 = new File(paramString2 + File.separator
+ paramString3);
} else if ((localFile2.exists()) && (!paramBoolean2)) {
return paramString3;
}
FileWriter localFileWriter = new FileWriter(localFile2);
OutputStreamWriter localOutputStreamWriter = new OutputStreamWriter(
new FileOutputStream(localFile2), "GBK");
StringBuffer localStringBuffer = new StringBuffer();
if (paramBoolean3) {
localStringBuffer.append(" <P> ");
for (int i = 0; i < paramString1.length(); i++)
if (new String(new char[] {paramString1.charAt(i) })
.equals(" ")) {
localStringBuffer.append(" ");
} else if (new String(new char[] {paramString1.charAt(i) })
.equals("\n")) {
localStringBuffer.append(" <br> ");
} else {
if (new String(new char[] {paramString1.charAt(i) })
.equals("\n"))
if ((new String(
new char[] {paramString1.charAt(i + 1) })
.equals("\n"))
&& (i + 1 != paramString1.length())) {
localStringBuffer.append(" </P><br><P> ");
i++;
continue;
}
localStringBuffer.append(new String(
new char[] {paramString1.charAt(i) }));
}
localStringBuffer.append("</P>");
paramString1 = localStringBuffer.toString();
}
localOutputStreamWriter.write(paramString1);
localOutputStreamWriter.close();
localFileWriter.close();
} catch (Exception localException) {
localException.printStackTrace();
return null;
}
return paramString3;
}
public static String readFile(String paramString, boolean paramBoolean) {
StringBuffer localStringBuffer = new StringBuffer();
try {
File localFile = new File(paramString);
if (!localFile.exists())
return localStringBuffer.toString();
FileInputStream localFileInputStream = new FileInputStream(
localFile);
BufferedReader localBufferedReader = new BufferedReader(
new InputStreamReader(localFileInputStream, "GBK"));
String str2 = "";
if (paramBoolean)
localStringBuffer.append("<p>");
while ((str2 = localBufferedReader.readLine()) != null) {
if (paramBoolean) {
str2 = substitute("s/ / /g", str2);
str2 = substitute("s/ / /g", str2);
}
if ((str2 == null) || ("".equals(str2)))
continue;
localStringBuffer.append(str2);
if (paramBoolean) {
localStringBuffer.append("</p><br><p>");
continue;
}
localStringBuffer.append("\n\r");
}
if (paramBoolean)
localStringBuffer.append("</p>");
} catch (Exception localException) {
localException.printStackTrace();
}
return localStringBuffer.toString();
}
public static String readFile(File paramFile) throws IOException {
StringBuffer localStringBuffer = new StringBuffer();
BufferedReader localBufferedReader = new BufferedReader(
new InputStreamReader(new FileInputStream(paramFile), "UTF-8"));
String str = "";
while ((str = localBufferedReader.readLine()) != null)
localStringBuffer.append(str);
return localStringBuffer.toString();
}
public static String substitute(String paramString1, String paramString2) {
if ((paramString2 == null) || (paramString1 == null))
return "";
Perl5Util localPerl5Util = new Perl5Util();
return localPerl5Util.substitute(paramString1, paramString2);
}
public static String uploadFileAndCallback(
MultipartFile paramMultipartFile, String paramString1,
String paramString2) {
if (validateFile(paramMultipartFile)) {
String str1 = paramMultipartFile.getOriginalFilename();
String str2 = str1.substring(str1.lastIndexOf(".")).toLowerCase();
String str3 = paramString2 + "-" + System.currentTimeMillis()
+ randomNumeric(new Random(), 6) + str2;
String str4 = paramString1 + str3;
File localFile1 = new File(RealPathUtil.getBigPicRealPath() + "/"
+ paramString1);
if (!localFile1.exists())
localFile1.mkdirs();
String str5 = RealPathUtil.getBigPicRealPath() + "/" + str4;
File localFile2 = new File(str5);
try {
FileCopyUtils.copy(paramMultipartFile.getBytes(), localFile2);
} catch (Exception localException) {
_$1.error("upload file:", localException);
}
return str4;
}
throw new InvalidFormatException(ResourceBundleHelper.getString(
"invalid.file.format", "invalid.file.format"), "24",
ResourceBundleHelper.getString("invalid.file.format",
"invalid.file.format"));
}
public static boolean validateFile(MultipartFile paramMultipartFile) {
if ((paramMultipartFile.getSize() < 0L)
|| (paramMultipartFile.getSize() > ((Long) PropertiesUtil
.getObject(ParameterEnum.MAX_FILE_SIZE, Long.class))
.longValue()))
return false;
String str1 = paramMultipartFile.getOriginalFilename();
String str2 = null;
try {
str2 = str1.substring(str1.lastIndexOf(".")).toLowerCase();
} catch (Exception localException) {
_$1.warn("can not get file extName,maybe there is not a file!");
return false;
}
List<?> localList = (List<?>) PropertiesUtil.getObject(
ParameterEnum.ALLOWED_UPLOAD_FILE_TPYE, List.class);
return localList.contains(str2);
}
}
| Java |
package com.legendshop.core.helper;
import com.legendshop.core.UserManager;
import com.legendshop.core.constant.FunctionEnum;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.dao.support.CriteriaQuery;
import com.legendshop.core.dao.support.HqlQuery;
import com.legendshop.core.dao.support.SqlQuery;
import com.legendshop.util.AppUtils;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.displaytag.util.ParamEncoder;
public class FunctionUtil {
public static boolean haveViewAllDataFunction(
HttpServletRequest paramHttpServletRequest) {
return UserManager.hasFunction(paramHttpServletRequest,
FunctionEnum.FUNCTION_VIEW_ALL_DATA.value());
}
public static boolean isDataSortByExternal(
CriteriaQuery paramCriteriaQuery,
HttpServletRequest paramHttpServletRequest) {
String str1 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("s"));
String str2 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("o"));
if (AppUtils.isNotBlank(str1)) {
if ("1".equals(str2))
paramCriteriaQuery.addOrder("desc", str1);
else
paramCriteriaQuery.addOrder("asc", str1);
return true;
}
return false;
}
public static boolean isDataSortByExternal(SqlQuery paramSqlQuery,
HttpServletRequest paramHttpServletRequest, Map<String, String> paramMap) {
String str1 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("s"));
String str2 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("o"));
if (AppUtils.isNotBlank(str1)) {
if ("1".equals(str2))
paramMap.put("orderIndicator", "order by " + str1 + " desc");
else
paramMap.put("orderIndicator", "order by " + str1 + " asc");
return true;
}
return false;
}
public static boolean isDataSortByExternal(HqlQuery paramHqlQuery,
HttpServletRequest paramHttpServletRequest, Map<String, String> paramMap) {
String str1 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("s"));
String str2 = paramHttpServletRequest.getParameter(new ParamEncoder(
"item").encodeParameterName("o"));
if (AppUtils.isNotBlank(str1)) {
if ("1".equals(str2))
paramMap.put("orderIndicator", "order by " + str1 + " desc");
else
paramMap.put("orderIndicator", "order by " + str1 + " asc");
return true;
}
return false;
}
public static boolean isDataForExport(CriteriaQuery paramCriteriaQuery,
HttpServletRequest paramHttpServletRequest) {
String str = paramHttpServletRequest.getParameter("6578706f7274");
if (AppUtils.isNotBlank(str)) {
paramCriteriaQuery.setPageSize(((Integer) PropertiesUtil.getObject(
ParameterEnum.EXPORT_SIZE, Integer.class)).intValue());
return true;
}
return false;
}
public static boolean isDataForExport(SqlQuery paramSqlQuery,
HttpServletRequest paramHttpServletRequest) {
String str = paramHttpServletRequest.getParameter("6578706f7274");
if (AppUtils.isNotBlank(str)) {
paramSqlQuery.setPageSize(((Integer) PropertiesUtil.getObject(
ParameterEnum.EXPORT_SIZE, Integer.class)).intValue());
return true;
}
return false;
}
public static boolean isDataForExport(HqlQuery paramHqlQuery,
HttpServletRequest paramHttpServletRequest) {
String str = paramHttpServletRequest.getParameter("6578706f7274");
if (AppUtils.isNotBlank(str)) {
paramHqlQuery.setPageSize(((Integer) PropertiesUtil.getObject(
ParameterEnum.EXPORT_SIZE, Integer.class)).intValue());
return true;
}
return false;
}
}
| Java |
package com.legendshop.core.helper;
import com.legendshop.model.entity.SystemParameter;
public abstract interface PropertiesUpdater {
public abstract boolean isSupport(SystemParameter paramSystemParameter);
public abstract void update(SystemParameter paramSystemParameter);
}
| Java |
package com.legendshop.core.helper;
import javax.servlet.ServletContext;
public class RealPathUtil {
public static String getBigPicRealPath() {
return PropertiesUtil.getBigFilesAbsolutePath();
}
public static String getSystemRealPath(ServletContext paramServletContext) {
return paramServletContext.getRealPath("/");
}
public static String getSmallPicRealPath() {
return PropertiesUtil.getSmallFilesAbsolutePath();
}
public static String getFCKRealPath(String paramString) {
String str1 = PropertiesUtil.getBigFilesAbsolutePath();
String str2 = PropertiesUtil.getUserFilesPathServlet();
String str3 = null;
if ((paramString != null) && (str2 != null))
str3 = paramString.substring(str2.length() + 1);
return str1 + "/" + str3;
}
}
| Java |
package com.legendshop.core.helper;
import javax.servlet.ServletContext;
import javax.sql.DataSource;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.web.context.support.WebApplicationContextUtils;
public class AddSpringBean {
public static void addDataSource(ServletContext paramServletContext,
DataSource paramDataSource) throws ClassNotFoundException {
DefaultListableBeanFactory localDefaultListableBeanFactory = (DefaultListableBeanFactory) WebApplicationContextUtils
.getWebApplicationContext(paramServletContext)
.getAutowireCapableBeanFactory();
AbstractBeanDefinition localAbstractBeanDefinition = BeanDefinitionReaderUtils
.createBeanDefinition(
null,
paramDataSource.getClass().getName(),
WebApplicationContextUtils.getWebApplicationContext(
paramServletContext).getClassLoader());
localDefaultListableBeanFactory.registerBeanDefinition("dataSource",
localAbstractBeanDefinition);
}
}
| Java |
package com.legendshop.core.helper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.legendshop.core.constant.ConfigPropertiesEnum;
import com.legendshop.core.constant.ParameterEnum;
import com.legendshop.core.constant.ParameterTypeEnum;
import com.legendshop.model.entity.SystemParameter;
import com.legendshop.util.AppUtils;
import com.legendshop.util.EnvironmentConfig;
import com.legendshop.util.TimerUtil;
import com.legendshop.util.converter.ByteConverter;
import com.legendshop.util.des.DES2;
public class PropertiesUtil {
private static Map<String, Object> _$2 = new HashMap<String, Object>();
private static String _$1;
public static String getSmallFilesAbsolutePath() {
String str = EnvironmentConfig.getInstance().getPropertyValue(
"config/common.properties",
ConfigPropertiesEnum.SMALL_PIC_PATH.name());
if (AppUtils.isBlank(str))
str = getSystemRealPath() + "smallImage";
return str;
}
public static String getBigFilesAbsolutePath() {
String str = EnvironmentConfig.getInstance().getPropertyValue(
"config/common.properties",
ConfigPropertiesEnum.BIG_PIC_PATH.name());
if (AppUtils.isBlank(str))
str = getSystemRealPath() + "bigImage";
return str;
}
public static String getBackupFilesAbsolutePath() {
String str = EnvironmentConfig.getInstance().getPropertyValue(
"config/common.properties",
ConfigPropertiesEnum.BACKUP_PIC_PATH.name());
if (AppUtils.isBlank(str))
str = getSystemRealPath() + "backupImage";
return str;
}
public static String getUserFilesPathServlet() {
return EnvironmentConfig.getInstance().getPropertyValue(
"fckeditor.properties", "connector.userFilesPath");
}
public static String getDomainName() {
return EnvironmentConfig.getInstance().getPropertyValue(
"config/common.properties", "DOMAIN_NAME");
}
public static String getDownloadFilePath() {
String str = EnvironmentConfig.getInstance().getPropertyValue(
"config/common.properties",
ConfigPropertiesEnum.DOWNLOAD_PATH.name());
if (AppUtils.isBlank(str))
str = getSystemRealPath() + "download";
return str;
}
public static String getLucenePath() {
String str = EnvironmentConfig.getInstance()
.getPropertyValue("config/common.properties",
ConfigPropertiesEnum.LUCENE_PATH.name());
if (AppUtils.isBlank(str))
str = getSystemRealPath() + "luceneIndex";
return str;
}
public static String getProperties(String paramString1, String paramString2) {
return EnvironmentConfig.getInstance().getPropertyValue(paramString1,
paramString2);
}
public static boolean isSystemInstalled() {
return "true".equals(getProperties("config/common.properties",
ConfigPropertiesEnum.INSTALLED.name()));
}
public static boolean isSystemInDebugMode() {
return "true".equals(getProperties("config/global.properties",
ConfigPropertiesEnum.SQL_DEBUG_MODE.name()));
}
public static String getCurrencyPattern() {
return EnvironmentConfig.getInstance().getPropertyValue(
"config/global.properties",
ConfigPropertiesEnum.CURRENCY_PATTERN.name());
}
public static String getWebSuffix() {
return EnvironmentConfig.getInstance().getPropertyValue(
"config/global.properties", ConfigPropertiesEnum.WEB_SUFFIX.name());
}
public static void writeProperties(String paramString,
Map<String, String> paramMap) {
EnvironmentConfig.getInstance().writeProperties(paramString, paramMap);
}
public static Object getObject(ParameterEnum paramParameterEnum,
Class<?> paramClass) {
if (paramClass != paramParameterEnum.getClazz())
throw new RuntimeException("Required Type = "
+ paramParameterEnum.getClazz() + ", but Actual Type = "
+ paramClass);
return _$2.get(paramParameterEnum.name());
}
public static Boolean getBooleanObject(String paramString) {
return (Boolean) _$2.get(paramString);
}
public static void setObject(ParameterEnum paramParameterEnum,
Object paramObject) {
if (paramObject.getClass() != paramParameterEnum.getClazz())
throw new RuntimeException("Required Type = "
+ paramParameterEnum.getClazz() + ", but Actual Type = "
+ paramObject.getClass());
_$2.put(paramParameterEnum.name(), paramObject);
}
public static void setParameter(SystemParameter paramSystemParameter,
PropertiesUpdater paramPropertiesUpdater) {
if ((paramPropertiesUpdater != null)
&& (paramPropertiesUpdater.isSupport(paramSystemParameter)))
paramPropertiesUpdater.update(paramSystemParameter);
String str1 = paramSystemParameter.getType();
if (ParameterTypeEnum.Integer.name().equalsIgnoreCase(str1)) {
try {
_$2.put(paramSystemParameter.getName(),
Integer.valueOf(paramSystemParameter.getValue()));
} catch (Exception localException1) {
_$2.put(paramSystemParameter.getName(),
Integer.valueOf(paramSystemParameter.getOptional()));
}
} else if (ParameterTypeEnum.Boolean.name().equalsIgnoreCase(str1)) {
_$2.put(paramSystemParameter.getName(),
Boolean.valueOf(paramSystemParameter.getValue()));
} else if (ParameterTypeEnum.Long.name().equalsIgnoreCase(str1)) {
try {
_$2.put(paramSystemParameter.getName(),
Long.valueOf(paramSystemParameter.getValue()));
} catch (Exception localException2) {
_$2.put(paramSystemParameter.getName(),
Integer.valueOf(paramSystemParameter.getOptional()));
}
} else if (ParameterTypeEnum.List.name().equalsIgnoreCase(str1)) {
ArrayList<String> localArrayList = new ArrayList<String>();
if (AppUtils.isNotBlank(paramSystemParameter.getValue())) {
String[] arrayOfString1 = paramSystemParameter.getValue()
.split(",");
for (String str2 : arrayOfString1)
localArrayList.add(str2);
}
_$2.put(paramSystemParameter.getName(), localArrayList);
} else {
_$2.put(paramSystemParameter.getName(),
paramSystemParameter.getValue());
}
}
public static String getDefaultShopName() {
return (String) getObject(ParameterEnum.DEFAULT_SHOP, String.class);
}
public static String getSystemRealPath() {
return _$1;
}
public static void setSystemRealPath(String paramString) {
_$1 = paramString;
}
public static String getLegendShopSystemId() {
return getProperties("config/common.properties",
ConfigPropertiesEnum.LEGENDSHOP_SYSTEM_ID.name());
}
public static void changeLegendShopSystemId() {
DES2 localDES2 = new DES2();
HashMap<String, String> localHashMap = new HashMap<String, String>();
String str1 = TimerUtil.getStrDate();
String str2 = ByteConverter.encode(localDES2.byteToString(localDES2
.createEncryptor(str1)));
localHashMap
.put(ConfigPropertiesEnum.LEGENDSHOP_SYSTEM_ID.name(), str2);
String str3 = getSystemRealPath()
+ "WEB-INF/classes/config/common.properties";
writeProperties(str3, localHashMap);
}
}
/*
* Location: E:\100mall\ROOT_\WEB-INF\lib\legendshop_core3.0.3.jar
* Qualified Name: com.legendshop.core.helper.PropertiesUtil
* JD-Core Version: 0.6.0
*/
| Java |
package com.legendshop.core.helper;
import javax.servlet.http.HttpServletRequest;
public abstract interface Checker<T> {
public abstract boolean check(T paramT,
HttpServletRequest paramHttpServletRequest);
}
| Java |
package com.legendshop.core.helper;
import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
public class ResourceBundleHelper {
public static String getString(String paramString) {
return ResourceBundle.getBundle("i18n/ApplicationResources").getString(
paramString);
}
public static String getString(String paramString1, String paramString2) {
String str;
try {
str = ResourceBundle.getBundle("i18n/ApplicationResources")
.getString(paramString1);
if (str == null)
str = paramString2;
} catch (Exception localException) {
str = paramString2;
}
return str;
}
public static String getDeleteString() {
return ResourceBundle.getBundle("i18n/ApplicationResources").getString(
"entity.deleted");
}
public static String getSucessfulString() {
return ResourceBundle.getBundle("i18n/ApplicationResources").getString(
"operation.successful");
}
public static String getErrorString() {
return ResourceBundle.getBundle("i18n/ApplicationResources").getString(
"SYSTEM_ERROR");
}
public static String getString(Locale paramLocale, String paramString1,
String paramString2) {
String str;
try {
if (paramLocale != null)
str = ResourceBundle.getBundle("i18n/ApplicationResources",
paramLocale).getString(paramString1);
else
str = ResourceBundle.getBundle("i18n/ApplicationResources")
.getString(paramString1);
if (str == null)
str = paramString2;
} catch (Exception localException) {
System.out.println(localException.getLocalizedMessage());
str = paramString2;
}
return str;
}
public static String getString(Locale paramLocale, String paramString) {
String str;
if (paramLocale != null)
str = ResourceBundle.getBundle("i18n/ApplicationResources",
paramLocale).getString(paramString);
else
str = ResourceBundle.getBundle("i18n/ApplicationResources")
.getString(paramString);
if (str == null)
throw new IllegalArgumentException(paramString + " was not found");
return str;
}
public static String getString(Locale paramLocale, String paramString,
Object[] paramArrayOfObject) {
return MessageFormat.format(getString(paramLocale, paramString),
paramArrayOfObject);
}
}
| Java |
package com.legendshop.core;
import com.legendshop.core.helper.PropertiesUtil;
public abstract interface AttributeKeys {
public static final String BACKUP_IMAGE = "backupImage";
public static final String SMALL_IMAGE = "smallImage";
public static final String DOWNLOAD_PATH = "download";
//TODO 需要修改
public static final String LEGENDSHOP_DOMAIN_NAME = "http://localhost:9090/";
public static final String BIG_IMAGE = "bigImage";
public static final String DOMAIN_NAME = "DOMAIN_NAME";
public static final String LUCENE_PATH = "luceneIndex";
public static final String SIMPLE_PAGE_PROVIDER = "SimplePageProvider";
public static final String LOCALE_FILE = "i18n/ApplicationResources";
public static final String LEGENSHOP_LICENSE = "LEGENSHOP_LICENSE";
public static final String UN_AUTH_MSG = "UN_AUTH_MSG";
public static final String AUTH_NORMAL = "NORMAL";
public static final String USER_NAME = "SPRING_SECURITY_LAST_USERNAME";
public static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
public static final String AUTH_SERVICE_NAME = "authService";
public static final String RETURN_URL = "returnUrl";
public static final String RUNTIME_MODE = "RUNTIME_MODE";
public static final String BUSINESS_MODE = "BUSINESS_MODE";
public static final String LANGUAGE_MODE = "LANGUAGE_MODE";
public static final String ORDER_INDICATOR = "orderIndicator";
public static final String TRUE_INDICATOR = "Y";
public static final String FALSE_INDICATOR = "N";
public static final String SHOP_NAME = "shopName";
public static final String SHOP_DETAIL = "shopDetail";
public static final String COMMON_USER = "common";
public static final Integer ONLINE = Integer.valueOf(1);
public static final Integer OFFLINE = Integer.valueOf(0);
public static final String WEB_SUFFIX = PropertiesUtil
.getWebSuffix();
public static final String LOCALE_KEY = "LOCALE_KEY";
public static final String EDITOR_PIC_PATH = "/editor";
public static final String RANDNUMBER = "LEGENDSHOP_RANDNUM";
public static final String LOCALE_RESOLVER = "localeResolver";
public static final String LOCALE_MESSAGE_PREFIX = "message:";
public static final String DEFAULT_PAGE = "default";
}
| Java |
package com.legendshop.core;
import javax.servlet.ServletContext;
public abstract interface StartupService {
public abstract void startup(ServletContext paramServletContext);
}
| Java |
package com.legendshop.core.security.model;
import com.legendshop.core.security.GrantedFunction;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
public class UserDetail extends User {
private static final long serialVersionUID = -5898134878028341628L;
private final Collection<GrantedFunction> _$2;
private final String _$1;
public UserDetail(String paramString1, String paramString2,
boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3,
boolean paramBoolean4, Collection<GrantedAuthority> paramCollection,
Collection<GrantedFunction> paramCollection1, String paramString3)
throws IllegalArgumentException {
super(paramString1, paramString2, paramBoolean1, paramBoolean2,
paramBoolean3, paramBoolean4, paramCollection);
this._$2 = paramCollection1;
this._$1 = paramString3;
}
public Collection<GrantedFunction> getFunctions() {
return this._$2;
}
public String getUserId() {
return this._$1;
}
}
| Java |
package com.legendshop.core.security;
import java.io.Serializable;
public abstract interface GrantedFunction extends Serializable {
public abstract String getFunction();
}
| Java |
package com.legendshop.core.security.service;
import com.legendshop.core.security.GrantedFunction;
import com.legendshop.model.entity.UserEntity;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;
public abstract interface FunctionService {
public abstract Collection<GrantedFunction> getFunctionsByUser(
UserEntity paramUserEntity);
public abstract Collection<GrantedFunction> getFunctionsByRoles(
Collection<? extends GrantedAuthority> paramCollection);
}
| Java |
package com.legendshop.core.security;
import java.io.Serializable;
public class GrantedFunctionImpl implements GrantedFunction, Serializable {
private static final long serialVersionUID = -8641327494044297777L;
private String function;
public GrantedFunctionImpl(String function) {
this.function = function;
}
protected GrantedFunctionImpl() {
throw new IllegalArgumentException("Cannot use default constructor");
}
public String getFunction() {
return this.function;
}
public boolean equals(Object paramObject) {
if ((paramObject instanceof String))
return paramObject.equals(this.function);
if ((paramObject instanceof Serializable)) {
GrantedFunction localGrantedFunction = (GrantedFunction) paramObject;
return this.function.equals(localGrantedFunction.getFunction());
}
return false;
}
public int hashCode() {
return this.function.hashCode();
}
public String toString() {
return this.function;
}
}
| Java |
package com.legendshop.core.security;
import java.util.Collection;
import java.util.Iterator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
public class MyAccessDecisionManager implements AccessDecisionManager {
Logger _$1 = LoggerFactory.getLogger(MyAccessDecisionManager.class);
public void decide(Authentication paramAuthentication, Object paramObject,
Collection<ConfigAttribute> paramCollection)
throws AccessDeniedException, InsufficientAuthenticationException {
this._$1.debug("decide calling {},{}", paramObject, paramCollection);
if (paramCollection == null)
return;
System.out.println("decide " + paramObject.toString());
Iterator<ConfigAttribute> localIterator1 = paramCollection.iterator();
while (localIterator1.hasNext()) {
ConfigAttribute localConfigAttribute = (ConfigAttribute) localIterator1
.next();
String str = ((SecurityConfig) localConfigAttribute).getAttribute();
Iterator<? extends GrantedAuthority> localIterator2 = paramAuthentication
.getAuthorities().iterator();
while (localIterator2.hasNext()) {
GrantedAuthority localGrantedAuthority = (GrantedAuthority) localIterator2
.next();
if (str.equals(localGrantedAuthority.getAuthority()))
return;
}
}
throw new AccessDeniedException("no right");
}
public boolean supports(ConfigAttribute paramConfigAttribute) {
return true;
}
public boolean supports(Class<?> paramClass) {
return true;
}
}
| Java |
package com.legendshop.core.security;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.springframework.util.Assert;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.filter.GenericFilterBean;
import com.legendshop.core.ContextServiceLocator;
public class DelegatingFilterProxy extends GenericFilterBean {
private String _$5;
private String _$4;
private boolean _$3 = false;
private Filter _$2;
private final Object _$1 = new Object();
public DelegatingFilterProxy() {
}
public DelegatingFilterProxy(Filter paramFilter) {
Assert.notNull(paramFilter, "delegate Filter object must not be null");
this._$2 = paramFilter;
}
public DelegatingFilterProxy(String paramString) {
this(paramString, null);
}
public DelegatingFilterProxy(String paramString,
WebApplicationContext paramWebApplicationContext) {
Assert.hasText(paramString,
"target Filter bean name must not be null or empty");
setTargetBeanName(paramString);
if (paramWebApplicationContext != null)
setEnvironment(paramWebApplicationContext.getEnvironment());
}
public void setContextAttribute(String paramString) {
this._$5 = paramString;
}
public String getContextAttribute() {
return this._$5;
}
public void setTargetBeanName(String paramString) {
this._$4 = paramString;
}
protected String getTargetBeanName() {
return this._$4;
}
public void setTargetFilterLifecycle(boolean paramBoolean) {
this._$3 = paramBoolean;
}
protected boolean isTargetFilterLifecycle() {
return this._$3;
}
protected void initFilterBean() throws ServletException {
synchronized (this._$1) {
if (this._$2 == null) {
if (this._$4 == null)
this._$4 = getFilterName();
WebApplicationContext localWebApplicationContext = findWebApplicationContext();
if (localWebApplicationContext != null)
this._$2 = initDelegate(localWebApplicationContext);
}
}
}
public void doFilter(ServletRequest paramServletRequest,
ServletResponse paramServletResponse, FilterChain paramFilterChain)
throws ServletException, IOException {
Filter localFilter = null;
synchronized (this._$1) {
if ((this._$2 == null)
|| (ContextServiceLocator.getInstance().isContextRefreshed())) {
WebApplicationContext localWebApplicationContext = findWebApplicationContext();
if (localWebApplicationContext == null)
throw new IllegalStateException(
"No WebApplicationContext found: no ContextLoaderListener registered?");
ContextServiceLocator.getInstance().setContextRefreshed(false);
this._$2 = initDelegate(localWebApplicationContext);
}
localFilter = this._$2;
}
invokeDelegate(localFilter, paramServletRequest, paramServletResponse,
paramFilterChain);
}
public void destroy() {
Filter localFilter = null;
synchronized (this._$1) {
localFilter = this._$2;
}
if (localFilter != null)
destroyDelegate(localFilter);
}
protected WebApplicationContext findWebApplicationContext() {
String str = getContextAttribute();
if (str != null)
return WebApplicationContextUtils.getWebApplicationContext(
getServletContext(), str);
return WebApplicationContextUtils
.getWebApplicationContext(getServletContext());
}
protected Filter initDelegate(
WebApplicationContext paramWebApplicationContext)
throws ServletException {
Filter localFilter = (Filter) paramWebApplicationContext.getBean(
getTargetBeanName(), Filter.class);
if (isTargetFilterLifecycle())
localFilter.init(getFilterConfig());
return localFilter;
}
protected void invokeDelegate(Filter paramFilter,
ServletRequest paramServletRequest,
ServletResponse paramServletResponse, FilterChain paramFilterChain)
throws ServletException, IOException {
paramFilter.doFilter(paramServletRequest, paramServletResponse,
paramFilterChain);
}
protected void destroyDelegate(Filter paramFilter) {
if (isTargetFilterLifecycle())
paramFilter.destroy();
}
}
| Java |
package com.legendshop.core.security;
import java.util.Map;
public abstract interface SecurityManager {
public abstract Map<String, String> getUrlAuthorities();
}
| Java |
package com.legendshop.core.security;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.SecurityMetadataSource;
import org.springframework.security.access.intercept.AbstractSecurityInterceptor;
import org.springframework.security.access.intercept.InterceptorStatusToken;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor
implements Filter {
private Logger _$2 = LoggerFactory
.getLogger(MyAccessDecisionManager.class);
private FilterInvocationSecurityMetadataSource _$1;
public void doFilter(ServletRequest paramServletRequest,
ServletResponse paramServletResponse, FilterChain paramFilterChain)
throws IOException, ServletException {
this._$2.debug("doFilter calling");
FilterInvocation localFilterInvocation = new FilterInvocation(
paramServletRequest, paramServletResponse, paramFilterChain);
invoke(localFilterInvocation);
}
public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {
return this._$1;
}
public Class<? extends Object> getSecureObjectClass() {
return FilterInvocation.class;
}
public void invoke(FilterInvocation paramFilterInvocation)
throws IOException, ServletException {
this._$2.debug("invoke calling");
InterceptorStatusToken localInterceptorStatusToken = super
.beforeInvocation(paramFilterInvocation);
try {
paramFilterInvocation.getChain().doFilter(
paramFilterInvocation.getRequest(),
paramFilterInvocation.getResponse());
} finally {
super.afterInvocation(localInterceptorStatusToken, null);
}
}
public SecurityMetadataSource obtainSecurityMetadataSource() {
return this._$1;
}
public void setSecurityMetadataSource(
FilterInvocationSecurityMetadataSource paramFilterInvocationSecurityMetadataSource) {
this._$1 = paramFilterInvocationSecurityMetadataSource;
}
public void destroy() {
}
public void init(FilterConfig paramFilterConfig) throws ServletException {
}
}
| Java |
package com.legendshop.core.security;
import com.legendshop.core.AttributeKeys;
import com.legendshop.core.UserManager;
import com.legendshop.core.constant.FunctionEnum;
import com.legendshop.util.AppUtils;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.security.web.RedirectStrategy;
public class OriginUrlRedirectStrategy implements RedirectStrategy {
protected final Log logger = LogFactory.getLog(getClass());
private boolean _$1;
public void sendRedirect(HttpServletRequest paramHttpServletRequest,
HttpServletResponse paramHttpServletResponse, String paramString)
throws IOException {
String str1 = paramHttpServletRequest.getParameter("returnUrl");
if (AppUtils.isNotBlank(str1)) {
paramHttpServletResponse.sendRedirect(str1);
return;
}
if (UserManager.hasFunction(paramHttpServletRequest,
FunctionEnum.FUNCTION_F_ADMIN.value())) {
paramHttpServletResponse.sendRedirect(paramHttpServletRequest
.getContextPath() + "/admin/index" + AttributeKeys.WEB_SUFFIX);
return;
}
String str2 = _$1(paramHttpServletRequest.getContextPath(), paramString);
str2 = paramHttpServletResponse.encodeRedirectURL(str2);
if (this.logger.isDebugEnabled())
this.logger.debug("Redirecting to '" + str2 + "'");
paramHttpServletResponse.sendRedirect(str2);
}
private String _$1(String paramString1, String paramString2) {
if ((paramString2 != null) && (!paramString2.startsWith("http://"))) {
if (this._$1)
return paramString2;
return paramString1 + paramString2;
}
if (!this._$1)
return paramString2;
paramString2 = paramString2.substring(paramString2.indexOf("://") + 3);
paramString2 = paramString2.substring(paramString2
.indexOf(paramString1) + paramString1.length());
if ((paramString2.length() > 1) && (paramString2.charAt(0) == '/'))
paramString2 = paramString2.substring(1);
return paramString2;
}
public void setContextRelative(boolean paramBoolean) {
this._$1 = paramBoolean;
}
}
/*
* Location: E:\100mall\ROOT_\WEB-INF\lib\legendshop_core3.0.3.jar
* Qualified Name: com.legendshop.core.security.OriginUrlRedirectStrategy
* JD-Core Version: 0.6.0
*/
| Java |
package com.legendshop.core;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetails;
import com.legendshop.core.security.GrantedFunction;
import com.legendshop.core.security.model.UserDetail;
import com.legendshop.core.security.service.FunctionService;
import com.legendshop.util.AppUtils;
public class UserManager {
private static Logger logger = LoggerFactory.getLogger(UserManager.class);
public static String getUsername(HttpSession paramHttpSession) {
SecurityContext localSecurityContext = (SecurityContext) paramHttpSession
.getAttribute("SPRING_SECURITY_CONTEXT");
if (localSecurityContext != null) {
Authentication localAuthentication = localSecurityContext
.getAuthentication();
if ((localAuthentication != null)
&& ((localAuthentication instanceof UsernamePasswordAuthenticationToken))) {
UserDetail localUserDetail = (UserDetail) ((UsernamePasswordAuthenticationToken) localAuthentication)
.getPrincipal();
return localUserDetail.getUsername();
}
}
return null;
}
public static String getUsername(HttpServletRequest paramHttpServletRequest) {
return getUsername(paramHttpServletRequest.getSession());
}
public static String getUserId(HttpSession paramHttpSession) {
SecurityContext localSecurityContext = (SecurityContext) paramHttpSession
.getAttribute("SPRING_SECURITY_CONTEXT");
if (localSecurityContext != null) {
Authentication localAuthentication = localSecurityContext
.getAuthentication();
if ((localAuthentication != null)
&& ((localAuthentication instanceof UsernamePasswordAuthenticationToken))) {
UserDetail localUserDetail = (UserDetail) ((UsernamePasswordAuthenticationToken) localAuthentication)
.getPrincipal();
return localUserDetail.getUserId();
}
logger.warn("Authentication is NULL!");
} else {
logger.warn("SecurityContext is NULL!");
}
return null;
}
public static String getUserId(HttpServletRequest paramHttpServletRequest) {
return getUserId(paramHttpServletRequest.getSession());
}
public static UserDetail getUser(HttpSession paramHttpSession) {
SecurityContext localSecurityContext = (SecurityContext) paramHttpSession
.getAttribute("SPRING_SECURITY_CONTEXT");
if (localSecurityContext != null) {
Authentication localAuthentication = localSecurityContext
.getAuthentication();
if ((localAuthentication != null)
&& ((localAuthentication instanceof UsernamePasswordAuthenticationToken))) {
UserDetail localUserDetail = (UserDetail) ((UsernamePasswordAuthenticationToken) localAuthentication)
.getPrincipal();
return localUserDetail;
}
logger.warn("Authentication is NULL!");
} else {
logger.warn("SecurityContext is NULL!");
}
return null;
}
public static String getPassword(HttpSession paramHttpSession) {
SecurityContext localSecurityContext = (SecurityContext) paramHttpSession
.getAttribute("SPRING_SECURITY_CONTEXT");
if (localSecurityContext != null) {
Authentication localAuthentication = localSecurityContext
.getAuthentication();
if ((localAuthentication != null)
&& ((localAuthentication instanceof UsernamePasswordAuthenticationToken))) {
UserDetail localUserDetail = (UserDetail) ((UsernamePasswordAuthenticationToken) localAuthentication)
.getPrincipal();
return localUserDetail.getPassword();
}
logger.warn("Authentication is NULL!");
} else {
logger.warn("SecurityContext is NULL!");
}
return null;
}
public static String getSessionID() {
SecurityContext localSecurityContext1 = SecurityContextHolder
.getContext();
if ((localSecurityContext1 != null)
&& ((localSecurityContext1 instanceof SecurityContext))) {
SecurityContext localSecurityContext2 = localSecurityContext1;
Authentication localAuthentication = localSecurityContext2
.getAuthentication();
if (localAuthentication != null) {
Object localObject = localAuthentication.getDetails();
if ((localObject instanceof WebAuthenticationDetails))
return ((WebAuthenticationDetails) localObject)
.getSessionId();
return null;
}
}
return null;
}
@SuppressWarnings("unchecked")
public static Collection<GrantedFunction> getPrincipalFunctionByAuthorities(
HttpSession paramHttpSession) {
SecurityContext localSecurityContext = (SecurityContext) paramHttpSession
.getAttribute("SPRING_SECURITY_CONTEXT");
if (null == localSecurityContext)
return Collections.EMPTY_LIST;
Authentication localAuthentication = localSecurityContext
.getAuthentication();
if (null == localAuthentication)
return Collections.EMPTY_LIST;
if ((null == localAuthentication.getAuthorities())
|| (localAuthentication.getAuthorities().size() < 1))
return Collections.EMPTY_LIST;
FunctionService localFunctionService = (FunctionService) ContextServiceLocator
.getInstance().getBean("authService");
Collection<GrantedFunction> localCollection = localFunctionService
.getFunctionsByRoles(localAuthentication.getAuthorities());
return localCollection;
}
public static boolean hasFunction(HttpSession paramHttpSession,
String paramString) {
Collection<GrantedFunction> localCollection = getPrincipalFunctionByAuthorities(paramHttpSession);
return _$1(localCollection, paramString);
}
public static boolean hasFunction(
HttpServletRequest paramHttpServletRequest, String paramString) {
return hasFunction(paramHttpServletRequest.getSession(), paramString);
}
public static boolean hasFunction(HttpSession paramHttpSession,
String[] paramArrayOfString) {
if (AppUtils.isBlank(paramArrayOfString))
return false;
Collection<GrantedFunction> localCollection = getPrincipalFunctionByAuthorities(paramHttpSession);
for (String str : paramArrayOfString)
if (!_$1(localCollection, str))
return false;
return true;
}
public static boolean hasFunction(
HttpServletRequest paramHttpServletRequest, String[] paramArrayOfString) {
return hasFunction(paramHttpServletRequest.getSession(),
paramArrayOfString);
}
private static boolean _$1(Collection<GrantedFunction> paramCollection,
String paramString) {
Iterator<GrantedFunction> localIterator = paramCollection.iterator();
while (localIterator.hasNext()) {
GrantedFunction localGrantedFunction = (GrantedFunction) localIterator
.next();
if (localGrantedFunction.equals(paramString))
return true;
}
return false;
}
}
| Java |
package com.legendshop.model.group;
import com.legendshop.model.entity.Product;
import java.util.Date;
public class GroupProduct
{
private Long _$17;
private Product _$16;
private Long _$15;
private Long _$14;
private String _$13;
private String _$12;
private Integer _$11;
private Integer _$10;
private Long _$9;
private Double _$8;
private Date _$7;
private Date _$6;
private Boolean _$5;
private Integer _$4;
private Integer _$3;
private Integer _$2;
private boolean _$1;
public Long getPartnerId()
{
return this._$14;
}
public void setPartnerId(Long paramLong)
{
this._$14 = paramLong;
}
public String getSuccessCause()
{
return this._$13;
}
public void setSuccessCause(String paramString)
{
this._$13 = paramString;
}
public String getBuyCondition()
{
return this._$12;
}
public void setBuyCondition(String paramString)
{
this._$12 = paramString;
}
public Integer getVisualBuys()
{
return this._$11;
}
public void setVisualBuys(Integer paramInteger)
{
this._$11 = paramInteger;
}
public Integer getMaxBuys()
{
return this._$10;
}
public void setMaxBuys(Integer paramInteger)
{
this._$10 = paramInteger;
}
public Long getDvyTypeId()
{
return this._$9;
}
public void setDvyTypeId(Long paramLong)
{
this._$9 = paramLong;
}
public Double getMaxMoney()
{
return this._$8;
}
public void setMaxMoney(Double paramDouble)
{
this._$8 = paramDouble;
}
public Date getCouponStartTime()
{
return this._$7;
}
public void setCouponStartTime(Date paramDate)
{
this._$7 = paramDate;
}
public Date getCouponEndTime()
{
return this._$6;
}
public void setCouponEndTime(Date paramDate)
{
this._$6 = paramDate;
}
public Boolean getSoldOut()
{
return this._$5;
}
public void setSoldOut(Boolean paramBoolean)
{
this._$5 = paramBoolean;
}
public Integer getSalesMin()
{
return this._$4;
}
public void setSalesMin(Integer paramInteger)
{
this._$4 = paramInteger;
}
public Integer getSalesNum()
{
return this._$3;
}
public void setSalesNum(Integer paramInteger)
{
this._$3 = paramInteger;
}
public Integer getSalesMax()
{
return this._$2;
}
public void setSalesMax(Integer paramInteger)
{
this._$2 = paramInteger;
}
public boolean getIsPost()
{
return this._$1;
}
public void setIsPost(boolean paramBoolean)
{
this._$1 = paramBoolean;
}
public Long getGroupProdId()
{
return this._$17;
}
public void setGroupProdId(Long paramLong)
{
this._$17 = paramLong;
}
public Long getProdId()
{
return this._$15;
}
public void setProdId(Long paramLong)
{
this._$15 = paramLong;
}
public Product getProduct()
{
return this._$16;
}
public void setProduct(Product paramProduct)
{
this._$16 = paramProduct;
}
public void setPost(boolean paramBoolean)
{
this._$1 = paramBoolean;
}
}
| Java |
package com.legendshop.group.controller;
import com.legendshop.core.base.BaseController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping({"/group"})
public class GroupController extends BaseController
{
private final Logger _$1 = LoggerFactory.getLogger(GroupController.class);
@RequestMapping({"/index"})
public String index(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse)
{
this._$1.debug("Index starting calling");
return "/group/default/index";
}
@RequestMapping({"/view/{id}"})
public String view(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse, @PathVariable String paramString)
{
this._$1.debug("view starting calling");
return "/group/default/view";
}
@RequestMapping({"/sort"})
public String sort(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse)
{
this._$1.debug("sort starting calling");
return "/group/default/sort";
}
@RequestMapping({"/question"})
public String question(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse)
{
this._$1.debug("question starting calling");
return "/group/default/question";
}
}
| Java |
package com.legendshop.group.controller;
import com.legendshop.core.base.BaseController;
import org.springframework.stereotype.Controller;
@Controller
public class GroupProductController extends BaseController
{
}
| Java |
package com.legendshop.group.controller;
import com.legendshop.core.base.BaseController;
import org.springframework.stereotype.Controller;
@Controller
public class GroupSortController extends BaseController
{
}
| Java |
package com.greysh.enter.model;
public class Admin {
private Integer adminId;
private String adminName;
private String adminPassword;
public Integer getAdminId() {
return adminId;
}
public void setAdminId(Integer adminId) {
this.adminId = adminId;
}
public String getAdminName() {
return adminName;
}
public void setAdminName(String adminName) {
this.adminName = adminName;
}
public String getAdminPassword() {
return adminPassword;
}
public void setAdminPassword(String adminPassword) {
this.adminPassword = adminPassword;
}
}
| Java |
package com.greysh.enter.service.impl;
import java.sql.SQLException;
import com.greysh.enter.dao.AdminDao;
import com.greysh.enter.model.Admin;
import com.greysh.enter.service.AdminService;
public class AdminServiceImpl implements AdminService {
private AdminDao adminDao;
//按用户名查询密码
public Admin findAdminByName(String name) throws SQLException{
Admin admin = new Admin();
admin = adminDao.selectAdminByName(name);
return admin;
}
public AdminDao getAdminDao() {
return adminDao;
}
public void setAdminDao(AdminDao adminDao) {
this.adminDao = adminDao;
}
@Override
public void deleteScore(Integer id) throws SQLException {
// TODO Auto-generated method stub
}
}
| Java |
package com.greysh.enter.service;
import java.sql.SQLException;
import com.greysh.enter.model.Admin;
public interface AdminService {
// 按ID查询成绩
void deleteScore(Integer id) throws SQLException;
// 按用户名查询密码
Admin findAdminByName(String name) throws SQLException;
}
| Java |
package com.greysh.enter.dao;
import java.sql.SQLException;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import com.greysh.enter.model.Admin;
public class AdminDao extends SqlMapClientDaoSupport {
// 删除考试
public void deleteTest(int id) throws SQLException {
getSqlMapClientTemplate().delete("deleteTestById", id);
}
// 删除考生成绩
public void deleteScore(int id) throws SQLException {
getSqlMapClientTemplate().delete("deleteScoreById", id);
}
// 按用户名查询密码
public Admin selectAdminByName(String name) throws SQLException {
return (Admin) getSqlMapClientTemplate().queryForObject(
"selectAdminByName", name);
}
}
| Java |
package com.greysh.enter.action;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.interceptor.SessionAware;
import com.greysh.enter.model.Admin;
import com.greysh.enter.service.AdminService;
import com.opensymphony.xwork2.ActionSupport;
public class AdminAction extends ActionSupport implements SessionAware {
private static final long serialVersionUID = 1L;
Admin admin;
AdminService adminService;
private Map<String, Object> session;
private HttpServletRequest request;
private int testId;
private int userId;
private int scoreId;
Admin tempAdmin;
// 管理员登录验证
public String login() {
try {
tempAdmin = adminService.findAdminByName(admin.getAdminName());
if ((tempAdmin.getAdminPassword()).equals(admin.getAdminPassword())) {
session.put("admin", tempAdmin);
System.out.println("Success");
return "login_success";
}
System.out.println("Falied");
return "login_success";
} catch (Exception e) {
e.printStackTrace();
System.out.println("Falied");
return "login_success";
}
}
public Admin getAdmin() {
return admin;
}
public void setAdmin(Admin admin) {
this.admin = admin;
}
public AdminService getAdminService() {
return adminService;
}
public void setAdminService(AdminService adminService) {
this.adminService = adminService;
}
public Map<String, Object> getSession() {
return session;
}
public void setSession(Map<String, Object> session) {
this.session = session;
}
public HttpServletRequest getRequest() {
return request;
}
public void setRequest(HttpServletRequest request) {
this.request = request;
}
public int getTestId() {
return testId;
}
public void setTestId(int testId) {
this.testId = testId;
}
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public int getScoreId() {
return scoreId;
}
public void setScoreId(int scoreId) {
this.scoreId = scoreId;
}
public Admin getTempAdmin() {
return tempAdmin;
}
public void setTempAdmin(Admin tempAdmin) {
this.tempAdmin = tempAdmin;
}
}
| Java |
package com.greysh.members.model;
import java.util.Date;
public class Member {
// Fields
private Integer memberPid;
private String memberName;
private String memberUniversity;
private String memberMajor;
private String memberEmail;
private Integer memberState;
private String memberHobby;
private String memberMsn;
private String memberPassword;
private String memberRealName;
private String memberBirthPlace;
private String memberCardId;
private Integer memberSchoolAge;
private Integer memberDegree;
private String memberEnterYear;
private String memberGradYear;
private Integer memberStudyState;
private Integer memberClass;
private String memberWorkspace;
private String memberDuty;
private String memberTitle;
private String memberPlace;
private String memberPostcode;
private String memberWorkPhone;
private String memberHomePhone;
private String memberTelephone;
private String memberQq;
private String memberDescription;
private Date memberBirthday;
// Constructors
/** default constructor */
public Member() {
}
public Integer getMemberPid() {
return memberPid;
}
public void setMemberPid(Integer memberPid) {
this.memberPid = memberPid;
}
public String getMemberName() {
return memberName;
}
public void setMemberName(String memberName) {
this.memberName = memberName;
}
public String getMemberUniversity() {
return memberUniversity;
}
public void setMemberUniversity(String memberUniversity) {
this.memberUniversity = memberUniversity;
}
public String getMemberMajor() {
return memberMajor;
}
public void setMemberMajor(String memberMajor) {
this.memberMajor = memberMajor;
}
public String getMemberEmail() {
return memberEmail;
}
public void setMemberEmail(String memberEmail) {
this.memberEmail = memberEmail;
}
public Integer getMemberState() {
return memberState;
}
public void setMemberState(Integer memberState) {
this.memberState = memberState;
}
public String getMemberHobby() {
return memberHobby;
}
public void setMemberHobby(String memberHobby) {
this.memberHobby = memberHobby;
}
public String getMemberMsn() {
return memberMsn;
}
public void setMemberMsn(String memberMsn) {
this.memberMsn = memberMsn;
}
public String getMemberPassword() {
return memberPassword;
}
public void setMemberPassword(String memberPassword) {
this.memberPassword = memberPassword;
}
public String getMemberRealName() {
return memberRealName;
}
public void setMemberRealName(String memberRealName) {
this.memberRealName = memberRealName;
}
public String getMemberBirthPlace() {
return memberBirthPlace;
}
public void setMemberBirthPlace(String memberBirthPlace) {
this.memberBirthPlace = memberBirthPlace;
}
public String getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(String memberCardId) {
this.memberCardId = memberCardId;
}
public Integer getMemberSchoolAge() {
return memberSchoolAge;
}
public void setMemberSchoolAge(Integer memberSchoolAge) {
this.memberSchoolAge = memberSchoolAge;
}
public Integer getMemberDegree() {
return memberDegree;
}
public void setMemberDegree(Integer memberDegree) {
this.memberDegree = memberDegree;
}
public String getMemberEnterYear() {
return memberEnterYear;
}
public void setMemberEnterYear(String memberEnterYear) {
this.memberEnterYear = memberEnterYear;
}
public String getMemberGradYear() {
return memberGradYear;
}
public void setMemberGradYear(String memberGradYear) {
this.memberGradYear = memberGradYear;
}
public Integer getMemberStudyState() {
return memberStudyState;
}
public void setMemberStudyState(Integer memberStudyState) {
this.memberStudyState = memberStudyState;
}
public Integer getMemberClass() {
return memberClass;
}
public void setMemberClass(Integer memberClass) {
this.memberClass = memberClass;
}
public String getMemberWorkspace() {
return memberWorkspace;
}
public void setMemberWorkspace(String memberWorkspace) {
this.memberWorkspace = memberWorkspace;
}
public String getMemberDuty() {
return memberDuty;
}
public void setMemberDuty(String memberDuty) {
this.memberDuty = memberDuty;
}
public String getMemberTitle() {
return memberTitle;
}
public void setMemberTitle(String memberTitle) {
this.memberTitle = memberTitle;
}
public String getMemberPlace() {
return memberPlace;
}
public void setMemberPlace(String memberPlace) {
this.memberPlace = memberPlace;
}
public String getMemberPostcode() {
return memberPostcode;
}
public void setMemberPostcode(String memberPostcode) {
this.memberPostcode = memberPostcode;
}
public String getMemberWorkPhone() {
return memberWorkPhone;
}
public void setMemberWorkPhone(String memberWorkPhone) {
this.memberWorkPhone = memberWorkPhone;
}
public String getMemberHomePhone() {
return memberHomePhone;
}
public void setMemberHomePhone(String memberHomePhone) {
this.memberHomePhone = memberHomePhone;
}
public String getMemberTelephone() {
return memberTelephone;
}
public void setMemberTelephone(String memberTelephone) {
this.memberTelephone = memberTelephone;
}
public String getMemberQq() {
return memberQq;
}
public void setMemberQq(String memberQq) {
this.memberQq = memberQq;
}
public String getMemberDescription() {
return memberDescription;
}
public void setMemberDescription(String memberDescription) {
this.memberDescription = memberDescription;
}
public Date getMemberBirthday() {
return memberBirthday;
}
public void setMemberBirthday(Date memberBirthday) {
this.memberBirthday = memberBirthday;
}
}
| Java |
package com.greysh.members.service;
import java.util.Date;
import java.util.List;
import com.greysh.members.model.Member;
/**
*
* 会员管理
*
*/
public interface MemberService {
/**
* 注册,添加会员
* @param member
*/
void saveMember(Member member);
/**
* 跟新会员信息
* @param member
*/
void updateMember(Member member);
/**
* 根据主键删除指定会员
* @param pid
*/
void deleteMemberByPid(Integer pid);
/**
* 根据主键查找会员
* @param pid
* @return
*/
Member findMemberByPid(Integer pid);
/**
* 查找指定大学的会员
* @param university
* @return
*/
List<Member> findMemberByUniversity(String university);
/**
* 查找指定区域的大学会员
* @param location
* @return
*/
List<Member> findMemberByLocation(String location);
/**
* 查找指定专业的大学会员
* @param major
* @return
*/
List<Member> findMemberByMajor(String major);
/**
* 查找指定必要年限的会员
* @param year
* @return
*/
List<Member> findMemberByGraduateYear(Date year);
/**
* 查找指定工作的会员
* @param job
* @return
*/
List<Member> findMemberByJob(String job);
/**
* 得到所有会员列表
* @return
*/
List<Member> findAllMembers();
void addMember(Member member);
Member findMemberByName(String memberName);
}
| Java |
package com.greysh.members.dao;
import java.util.ArrayList;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import com.greysh.members.model.Member;
public class MemberDao extends SqlMapClientDaoSupport {
@SuppressWarnings("unchecked")
public ArrayList<Member> findMember(Member member){
return (ArrayList<Member>) getSqlMapClientTemplate().queryForList(
"selectMembers", member);
}
public void insertMember(Member member) {
getSqlMapClientTemplate().insert("insertMember", member);
}
} | Java |
package com.greysh.members.action;
/**
*
* 后台管理员
*
*/
public class MemberAdminAction {
/**
*
* @return 管理员显示所有的会员列表
*/
public String showMembersList(){
return null;
}
/**
*
* @return 管理员查看单个会员
*/
public String showMember(){
return null;
}
/**
*
* @return 修改档会员资料
*/
public String modifyMember(){
return null;
}
/**
*
* @return 修改会员后的页面
*/
public String afterModify(){
return null;
}
/**
*
* @return 删除会员后的页面
*/
public String afterDelete(){
return null;
}
}
| Java |
package com.greysh.members.action;
import com.greysh.members.model.Member;
import com.greysh.members.service.MemberService;
import com.opensymphony.xwork2.ActionSupport;
/**
*
*用户登陆
*
*/
public class MemberLoginAction extends ActionSupport{
/**
*
*/
private static final long serialVersionUID = 1L;
private Member member;
private MemberService memberService ;
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
public MemberService getMemberService() {
return memberService;
}
public void setMemberService(MemberService memberService) {
this.memberService = memberService;
}
public String beforeLogin(){
return "login";
}
/**
*
* @return 登陆
*/
public String login(){
System.out.println("public String login()");
System.out.println(member.getMemberName());
System.out.println(member.getMemberPassword());
Member tempMember = memberService.findMemberByName(member.getMemberName());
if(tempMember !=null){
if(tempMember.getMemberPassword().equals(member.getMemberPassword()))
return "login_success";
}
return "login_error";
}
/**
*
* @return 注销
*/
public String logout(){
return null;
}
// public void validate()
// {
// if (null == this.getMember().getMemberName()|| "".equals(this.getMember().getMemberName().trim()))
// {
// System.out.println("Membername required");
// this.addFieldError("member.memberName", "Membername required");
// }
// if (null == this.getMember().getMemberPassword() || "".equals(this.getMember().getMemberPassword().trim()))
// {
// System.out.println("password required");
// this.addFieldError("member.memberName", "password required");
// }
// }
}
| Java |
package com.greysh.members.action;
import com.greysh.members.model.Member;
import com.greysh.members.service.MemberService;
/**
*
* 前台用户
*
*/
public class MemberAction {
private MemberService memberService;
private Member member;
/**
*
* @return 跳转到注册页面
*/
public String beforeJoin(){
System.out.println("public String beforeJoin()");
return "join";
}
/**
*
* @return 注册
*/
public String join(){
memberService.addMember(member);
if(true)
return "join_success";
else
return "join_error";
}
/**
*
* @return 注册后页面
*/
public String afterJoin(){
return null;
}
/**
*
* @return 会员修改个人资料的页面
*/
public String beforeModify(){
return null;
}
/**
*
* @return 会员修改页面
*/
public String modify(){
return null;
}
/**
*
* @return 会员修改页面的返回页面
*/
public String afterModify(){
return null;
}
public MemberService getMemberService() {
return memberService;
}
public void setMemberService(MemberService memberService) {
this.memberService = memberService;
}
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
}
| Java |
package com.greysh.members.action;
/**
*
* 用户搜索
*
*/
public class MemberSearchAction {
/**
*
* @return 跳转到搜索页面
*/
public String beforeSearch() {
return null;
}
/**
*
* @return 搜索处理页面
*/
public String Search() {
return null;
}
/**
*
* @return 搜索结果页面
*/
public String afterSearch() {
return null;
}
}
| Java |
package com.greysh.event.model;
import java.util.Date;
public class Event{
private Integer eventPid;
private String eventTitle;
private String eventContent;
private Date eventDate;
// Constructors
/** default constructor */
public Event() {
}
public Integer getEventPid() {
return eventPid;
}
public void setEventPid(Integer eventPid) {
this.eventPid = eventPid;
}
public String getEventTitle() {
return eventTitle;
}
public void setEventTitle(String eventTitle) {
this.eventTitle = eventTitle;
}
public String getEventContent() {
return eventContent;
}
public void setEventContent(String eventContent) {
this.eventContent = eventContent;
}
public Date getEventDate() {
return eventDate;
}
public void setEventDate(Date eventDate) {
this.eventDate = eventDate;
}
} | Java |
package com.greysh.event.service;
import java.util.List;
import com.greysh.event.model.Event;
/**
*
* 校友会活动
*
*/
public interface EventService {
void saveEvent(Event event);
void updateEvent(Event event);
void deleteEventByPid(Integer pid);
Event findEventByPid(Integer pid);
Event findEventByName(String name);
List<Event> findAllEvent();
}
| Java |
package com.greysh.event.action;
/**
*
*后台管理
*
*/
public class EventAdminAction {
/**
*
* @return 后台显示活动列表
*/
public String showEventList(){
return null;
}
/**
*
* @return 后台显示单个活动
*/
public String showEvent(){
return null;
}
/**
*
* @return 修改活动前的页面
*/
public String beforeUpdateEvent(){
return null;
}
/**
*
* @return 跟新活动,跳转到结果页面
*/
public String updateEvent(){
return null;
}
/**
*
* @return 删除活动,跳转到结果页面
*/
public String deleteEvent(){
return null;
}
} | Java |
package com.greysh.event.action;
/**
*
* 前台活动信息
*
*/
public class EventAction{
/**
*
* @return 活动信息列表
*/
public String showEventsList(){
return null;
}
/**
*
* @return 显示单个活动信息
*/
public String showEvents(){
return null;
}
} | Java |
package com.greysh.jobs.model;
import java.util.Date;
public class Job {
private Integer jobId;
private String jobName;
private String jobDescription;
private Date jobDate;
public Job(){}
public Integer getJobId() {
return jobId;
}
public void setJobId(Integer jobId) {
this.jobId = jobId;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobDescription() {
return jobDescription;
}
public void setJobDescription(String jobDescription) {
this.jobDescription = jobDescription;
}
public Date getJobDate() {
return jobDate;
}
public void setJobDate(Date jobDate) {
this.jobDate = jobDate;
}
}
| Java |
package com.greysh.jobs.service.impl;
public class JobServiceImpl{
} | Java |
package com.greysh.jobs.service;
import java.util.List;
import com.greysh.jobs.model.Job;
/**
*
*工作信息相关
*/
public interface JobsService {
/**
* 保存工作信息
* @param job
*/
void saveJob(Job job);
/**
* 跟新工作信息
* @param job
*/
void updateJob(Job job);
/**
* 根据主键删除工作信息
* @param pid
*/
void deleteJobByPid(Integer pid);
/**
*
* @param pid
* @return 根据主键查找指定工作
*/
Job findJobByPid(Integer pid);
/**
*
* @return 得到所有工作列表
*/
List<Job> findAllJob();
}
| Java |
package com.greysh.jobs.dao;
public class JobDao{
} | Java |
package com.greysh.jobs.action;
/**
*
*后台管理
*
*/
public class JobAdminAction {
/**
*
* @return 后台显示工作信息列表
*/
public String showJobList(){
return null;
}
/**
*
* @return 后台显示单个工作信息
*/
public String showJob(){
return null;
}
/**
*
* @return 修改工作信息前的页面
*/
public String beforeUpdateJob(){
return null;
}
/**
*
* @return 跟新工作信息,跳转到结果页面
*/
public String updateJob(){
return null;
}
/**
*
* @return 删除工作信息,跳转到结果页面
*/
public String deleteJob(){
return null;
}
} | Java |
package com.greysh.jobs.action;
/**
*
* 前台工作信息
*
*/
public class JobAction{
/**
*
* @return 工作信息列表
*/
public String showJobsList(){
return null;
}
/**
*
* @return 显示单个工作信息
*/
public String showJobs(){
return null;
}
} | Java |
package com.greysh.news.model;
import java.util.Date;
public class News {
// Fields
private Integer newsPid;
private String newsTitle;
private String newsContent;
private Date newsDate;
// Constructors
/** default constructor */
public News() {
}
public Integer getNewsPid() {
return newsPid;
}
public void setNewsPid(Integer newsPid) {
this.newsPid = newsPid;
}
public String getNewsTitle() {
return newsTitle;
}
public void setNewsTitle(String newsTitle) {
this.newsTitle = newsTitle;
}
public String getNewsContent() {
return newsContent;
}
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
public Date getNewsDate() {
return newsDate;
}
public void setNewsDate(Date newsDate) {
this.newsDate = newsDate;
}
}
| Java |
package com.greysh.news.service;
import java.util.List;
import com.greysh.news.model.News;
/**
*
* 新闻管理
*
*/
public interface NewsService {
/**
* 保存新闻
* @param news
*/
void saveNews(News news);
/**
* 跟新新闻
* @param news
*/
void updateNews(News news);
/**
* 根据主键删除新闻
* @param pid
*/
void deleteNewsByPid(Integer pid);
/**
*
* @param pid
* @return 根据主键查找新闻
*/
News findNewsByPid(Integer pid);
/**
*
* @return 得到所有新闻列表
*/
List<News> findAllNews();
}
| Java |
package com.greysh.news.dao;
public class NewsDao{
} | Java |
package com.greysh.news.action;
/**
*
* 前台新闻
*
*/
public class NewsAction{
/**
*
* @return 新闻列表
*/
public String showNewsList(){
return null;
}
/**
*
* @return 显示单个新闻
*/
public String showNews(){
return null;
}
} | Java |
package com.greysh.news.action;
/**
*
*后台管理
*
*/
public class NewsAdminAction {
/**
*
* @return 后台显示新闻列表
*/
public String showNewsList(){
return null;
}
/**
*
* @return 后台显示单个新闻
*/
public String showNews(){
return null;
}
/**
*
* @return 修改新闻前的页面
*/
public String beforeUpdateNews(){
return null;
}
/**
*
* @return 跟新新闻,跳转到结果页面
*/
public String updateNews(){
return null;
}
/**
*
* @return 删除新闻,跳转到结果页面
*/
public String deleteNews(){
return null;
}
}
| Java |
package com.greysh.donation.model;
import java.util.Date;
public class Donation{
// Fields
private Integer donationPid;
private String donationTitle;
private Date donationDate;
private String donationContent;
// Constructors
/** default constructor */
public Donation() {
}
public Integer getDonationPid() {
return donationPid;
}
public void setDonationPid(Integer donationPid) {
this.donationPid = donationPid;
}
public String getDonationTitle() {
return donationTitle;
}
public void setDonationTitle(String donationTitle) {
this.donationTitle = donationTitle;
}
public Date getDonationDate() {
return donationDate;
}
public void setDonationDate(Date donationDate) {
this.donationDate = donationDate;
}
public String getDonationContent() {
return donationContent;
}
public void setDonationContent(String donationContent) {
this.donationContent = donationContent;
}
} | Java |
package com.greysh.donation.service;
public interface DonationService {
}
| Java |
package com.greysh.donation.action;
/**
*
*后台管理
*
*/
public class DonationAdminAction {
/**
*
* @return 后台显示捐献列表
*/
public String showDonationList(){
return null;
}
/**
*
* @return 后台显示单个捐献
*/
public String showDonation(){
return null;
}
/**
*
* @return 修改捐献前的页面
*/
public String beforeUpdateDonation(){
return null;
}
/**
*
* @return 跟新捐献,跳转到结果页面
*/
public String updateDonation(){
return null;
}
/**
*
* @return 删除捐献,跳转到结果页面
*/
public String deleteDonation(){
return null;
}
}
| Java |
package com.greysh.donation.action;
/**
*
* 前台捐赠信息
*
*/
public class DonationAction{
/**
*
* @return 捐赠信息列表
*/
public String showDonationList(){
return null;
}
/**
*
* @return 显示单个捐赠信息
*/
public String showDonation(){
return null;
}
} | Java |
/*-
* Copyright (C) 2010 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.client.android.vlcremote;
import junit.framework.TestCase;
public class VLCTest extends TestCase {
public void testFileUri() {
assertEquals("file:///C%3A/Users/Peter/Music/Fran%C3%A7ais",
VLC.fileUri("C:\\Users\\Peter\\Music/Français"));
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.intent;
import org.peterbaldwin.vlcremote.model.Status;
import android.content.Intent;
import android.graphics.Bitmap;
public final class Intents {
/**
* Plays a media URI with VLC (usually streaming audio/video).
* <p>
* For example, {@code http://www.example.com/video.mp4}
*/
public static final String ACTION_VIEW = "org.peterbaldwin.vlcremote.intent.action.VIEW";
/**
* Plays a browse URI (local file).
* <p>
* For example,
* {@code http://mediaserver/requests/browse.xml?dir=...&file=...}
*/
public static final String ACTION_PLAY = "org.peterbaldwin.vlcremote.intent.action.PLAY";
/**
* Streams a media file.
*/
public static final String ACTION_STREAM = "org.peterbaldwin.vlcremote.intent.action.STREAM";
/**
* Enqueues a browse URI (local file).
* <p>
* For example,
* {@code http://mediaserver/requests/browse.xml?dir=...&file=...}
*/
public static final String ACTION_ENQUEUE = "org.peterbaldwin.vlcremote.intent.action.ENQUEUE";
public static final String ACTION_MANUAL_APPWIDGET_UPDATE = "org.peterbaldwin.vlcremote.intent.action.MANUAL_APPWIDGET_UPDATE";
public static final String ACTION_STATUS = "org.peterbaldwin.vlcremote.intent.action.STATUS";
public static final String ACTION_PLAYLIST = "org.peterbaldwin.vlcremote.intent.action.PLAYLIST";
public static final String ACTION_ART = "org.peterbaldwin.vlcremote.intent.action.ART";
public static final String ACTION_ERROR = "org.peterbaldwin.vlcremote.intent.action.ERROR";
public static final String EXTRA_STATUS = "org.peterbaldwin.vlcremote.intent.extra.STATUS";
public static final String EXTRA_PLAYLIST = "org.peterbaldwin.vlcremote.intent.extra.PLAYLIST";
public static final String EXTRA_BITMAP = "org.peterbaldwin.vlcremote.intent.extra.BITMAP";
public static final String EXTRA_THROWABLE = "org.peterbaldwin.vlcremote.intent.extra.THROWABLE";
public static final String EXTRA_FLAGS = "org.peterbaldwin.vlcremote.intent.extra.FLAGS";
public static final String ACTION_REMOTE_VIEW = "org.openintents.remote.intent.action.VIEW";
public static final String EXTRA_REMOTE_HOST = "org.openintents.remote.intent.extra.HOST";
public static final String EXTRA_REMOTE_PORT = "org.openintents.remote.intent.extra.PORT";
/**
* Indicates if the command was generated by the user or programmatically.
* <p>
* This value is echoed back in the broadcast response.
* <p>
* The value can be used to determine whether or not it is appropriate to
* display an error message to the user.
*/
public static final int FLAG_PROGRAMMATIC = 1 << 0;
/**
* Instructs the service to only run the command if the media is playing.
*/
public static final int FLAG_ONLY_IF_PLAYING = 1 << 1;
/**
* Instructs the service to only run the command if the media is paused.
*/
public static final int FLAG_ONLY_IF_PAUSED = 1 << 2;
/**
* Instructs the service to call {@link VLC#setResumeOnIdle()} if and only
* if the command is executed successfully.
*/
public static final int FLAG_SET_RESUME_ON_IDLE = 1 << 3;
public static Intent status(Status status) {
Intent intent = new Intent(ACTION_STATUS);
intent.putExtra(EXTRA_STATUS, status);
return intent;
}
public static Intent art(Bitmap bitmap) {
Intent intent = new Intent(ACTION_ART);
intent.putExtra(EXTRA_BITMAP, bitmap);
return intent;
}
public static Intent error(Throwable t) {
Intent intent = new Intent(ACTION_ERROR);
intent.putExtra(EXTRA_THROWABLE, t);
return intent;
}
private Intents() {
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.service;
import org.peterbaldwin.vlcremote.intent.Intents;
import org.peterbaldwin.vlcremote.model.Preferences;
import org.peterbaldwin.vlcremote.model.Status;
import org.peterbaldwin.vlcremote.net.MediaServer;
import android.app.Service;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.util.Log;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Sends commands to a VLC server and receives & broadcasts the status.
*/
public class StatusService extends Service implements Handler.Callback {
private static final String TAG = "StatusService";
private static final int HANDLE_STATUS = 1;
private static final int HANDLE_ALBUM_ART = 2;
private static final int HANDLE_STOP = 3;
private static boolean isCommand(Uri uri) {
return uri.getQueryParameters("command").size() != 0;
}
/**
* Erases any commands from the URI.
*/
private static Uri readOnly(Uri uri) {
Uri.Builder builder = uri.buildUpon();
builder.encodedQuery("");
return builder.build();
}
private static boolean isSeek(Uri uri) {
return "seek".equals(uri.getQueryParameter("command"));
}
private static boolean isVolume(Uri uri) {
return "volume".equals(uri.getQueryParameter("command"));
}
private static boolean isAbsoluteValue(Uri uri) {
String value = uri.getQueryParameter("val");
return value != null && !value.startsWith("+") && !value.startsWith("-");
}
private Handler mStatusHandler;
private Handler mAlbumArtHandler;
private Handler mCommandHandler;
private AtomicInteger mSequenceNumber;
@Override
public void onCreate() {
super.onCreate();
mSequenceNumber = new AtomicInteger();
mStatusHandler = startHandlerThread("StatusThread");
// Create a separate thread for album art requests
// because the request can be very slow.
mAlbumArtHandler = startHandlerThread("AlbumArtThread");
// Create a separate thread for commands to improve latency
// (commands shouldn't have to wait for partially complete reads).
mCommandHandler = startHandlerThread("CommandThread");
}
@Override
public void onDestroy() {
stopHandlerThread(mStatusHandler);
stopHandlerThread(mCommandHandler);
stopHandlerThread(mAlbumArtHandler);
super.onDestroy();
}
private Handler startHandlerThread(String name) {
HandlerThread thread = new HandlerThread(name, Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
Looper looper = thread.getLooper();
Handler.Callback callback = this;
return new Handler(looper, callback);
}
private void stopHandlerThread(Handler handler) {
Looper looper = handler.getLooper();
looper.quit();
}
@Override
public void onStart(Intent intent, int startId) {
super.onStart(intent, startId);
String action = (intent != null) ? intent.getAction() : null;
Uri uri = (intent != null) ? intent.getData() : null;
if (Intents.ACTION_STATUS.equals(action) && uri != null) {
if (isCommand(uri)) {
// A command will change the status,
// so cancel any unsent requests to
// query the status
mStatusHandler.removeMessages(HANDLE_STATUS);
}
if (isSeek(uri) || isVolume(uri)) {
if (isAbsoluteValue(uri)) {
// Seeking to an absolute position or volume
// invalidates any existing requests to change
// the position or volume.
mCommandHandler.removeMessages(HANDLE_STATUS);
}
}
Handler handler = isCommand(uri) ? mCommandHandler : mStatusHandler;
if (isCommand(uri) || !handler.hasMessages(HANDLE_STATUS)) {
int sequenceNumber = isCommand(uri) ? mSequenceNumber.incrementAndGet()
: mSequenceNumber.get();
int flags = intent.getIntExtra(Intents.EXTRA_FLAGS, 0);
Message msg = handler.obtainMessage(HANDLE_STATUS, sequenceNumber, flags, uri);
handler.sendMessage(msg);
}
} else if (Intents.ACTION_ART.equals(action) && uri != null) {
int sequenceNumber = mSequenceNumber.get();
Message msg = mAlbumArtHandler.obtainMessage(HANDLE_ALBUM_ART, sequenceNumber, -1, uri);
msg.sendToTarget();
}
{
// Stop the service if no new Intents are received for 20 seconds
Handler handler = mCommandHandler;
Message msg = handler.obtainMessage(HANDLE_STOP, startId, -1);
handler.sendMessageDelayed(msg, 20 * 1000);
}
}
/** {@inheritDoc} */
public boolean handleMessage(Message msg) {
switch (msg.what) {
case HANDLE_STATUS: {
Uri uri = (Uri) msg.obj;
MediaServer server = new MediaServer(this, uri);
int sequenceNumber = msg.arg1;
int flags = msg.arg2;
if (sequenceNumber == mSequenceNumber.get()) {
boolean setResumeOnIdle = ((flags & Intents.FLAG_SET_RESUME_ON_IDLE) != 0);
boolean onlyIfPlaying = ((flags & Intents.FLAG_ONLY_IF_PLAYING) != 0);
boolean onlyIfPaused = ((flags & Intents.FLAG_ONLY_IF_PAUSED) != 0);
boolean conditional = onlyIfPlaying || onlyIfPaused;
try {
if (conditional) {
Status status = server.status().read();
if (onlyIfPlaying && !status.isPlaying()) {
return true;
}
if (onlyIfPaused && !status.isPaused()) {
return true;
}
}
Status status = server.status(uri).read();
if (sequenceNumber == mSequenceNumber.get()) {
sendBroadcast(Intents.status(status));
if (isCommand(uri)) {
// Check the status again after the command
// has had time to take effect.
msg = mStatusHandler.obtainMessage(HANDLE_STATUS, sequenceNumber,
0, readOnly(uri));
mStatusHandler.sendMessageDelayed(msg, 500);
}
} else {
Log.d(TAG, "Dropped stale status response: " + uri);
}
if (setResumeOnIdle) {
Preferences.get(this).setResumeOnIdle();
}
} catch (Throwable tr) {
String message = String.valueOf(tr);
Log.e(TAG, message, tr);
Intent broadcast = Intents.error(tr);
broadcast.putExtra(Intents.EXTRA_FLAGS, flags);
sendBroadcast(broadcast);
}
} else {
Log.d(TAG, "Dropped stale status request: " + uri);
}
return true;
}
case HANDLE_ALBUM_ART: {
Uri uri = (Uri) msg.obj;
MediaServer server = new MediaServer(this, uri);
int sequenceNumber = msg.arg1;
if (sequenceNumber == mSequenceNumber.get()) {
try {
Bitmap bitmap = server.image(uri).read();
if (sequenceNumber == mSequenceNumber.get()) {
sendBroadcast(Intents.art(bitmap));
} else {
Log.d(TAG, "Dropped stale album art response: " + uri);
}
} catch (Throwable tr) {
String message = String.valueOf(tr);
Log.e(TAG, message, tr);
sendBroadcast(Intents.error(tr));
}
} else {
Log.d(TAG, "Dropped stale album art request: " + uri);
}
return true;
}
case HANDLE_STOP: {
int startId = msg.arg1;
stopSelf(startId);
return true;
}
default:
return false;
}
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}
| Java |
/*-
* Copyright (C) 2010 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.receiver;
import org.peterbaldwin.vlcremote.model.Preferences;
import org.peterbaldwin.vlcremote.net.MediaServer;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.telephony.TelephonyManager;
/**
* Automatically pauses media when there is an incoming call.
*/
public class PhoneStateChangedReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (TelephonyManager.ACTION_PHONE_STATE_CHANGED.equals(action)) {
Preferences preferences = Preferences.get(context);
String authority = preferences.getAuthority();
if (authority != null) {
MediaServer server = new MediaServer(context, authority);
String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
if (TelephonyManager.EXTRA_STATE_RINGING.equals(state)
|| TelephonyManager.EXTRA_STATE_OFFHOOK.equals(state)) {
// Pause for both incoming and outgoing calls
server.status().onlyIfPlaying().setResumeOnIdle().command.playback.pause();
} else if (TelephonyManager.EXTRA_STATE_IDLE.equals(state)) {
if (preferences.isResumeOnIdleSet()) {
server.status().onlyIfPaused().command.playback.pause();
preferences.clearResumeOnIdle();
}
}
}
}
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.app;
import org.peterbaldwin.client.android.vlcremote.R;
import org.peterbaldwin.vlcremote.fragment.ArtFragment;
import org.peterbaldwin.vlcremote.fragment.BrowseFragment;
import org.peterbaldwin.vlcremote.fragment.ButtonsFragment;
import org.peterbaldwin.vlcremote.fragment.HotkeyDialog;
import org.peterbaldwin.vlcremote.fragment.HotkeyListener;
import org.peterbaldwin.vlcremote.fragment.InfoFragment;
import org.peterbaldwin.vlcremote.fragment.NavigationFragment;
import org.peterbaldwin.vlcremote.fragment.PlaybackFragment;
import org.peterbaldwin.vlcremote.fragment.PlaylistFragment;
import org.peterbaldwin.vlcremote.fragment.ServicesDiscoveryFragment;
import org.peterbaldwin.vlcremote.fragment.StatusFragment;
import org.peterbaldwin.vlcremote.fragment.VolumeFragment;
import org.peterbaldwin.vlcremote.intent.Intents;
import org.peterbaldwin.vlcremote.model.Preferences;
import org.peterbaldwin.vlcremote.model.Status;
import org.peterbaldwin.vlcremote.net.MediaServer;
import org.peterbaldwin.vlcremote.widget.VolumePanel;
import android.app.SearchManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Browser;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageButton;
import android.widget.SlidingDrawer;
import android.widget.TabHost;
import android.widget.ViewFlipper;
import java.util.ArrayList;
public class PlaybackActivity extends FragmentActivity implements TabHost.OnTabChangeListener,
View.OnClickListener, HotkeyListener {
private static final String TAG = "PlaybackActivity";
private static final int REQUEST_PICK_SERVER = 1;
private static final Uri URI_TROUBLESHOOTING = Uri
.parse("http://code.google.com/p/android-vlc-remote/wiki/Troubleshooting");
private static final String FRAGMENT_STATUS = "vlc:status";
private static final int VOLUME_LEVEL_UNKNOWN = -1;
private static final String STATE_INPUT = "vlc:input";
private static final String STATE_TAB = "vlc:tab";
private static final String TAB_MEDIA = "media";
private static final String TAB_PLAYLIST = "playlist";
private static final String TAB_BROWSE = "browse";
private static final String TAB_NAVIGATION = "navigation";
private static final int MAX_VOLUME = 1024;
private MediaServer mMediaServer;
private TabHost mTabHost;
private PlaybackFragment mPlayback;
private ArtFragment mArt;
private ButtonsFragment mButtons;
private VolumeFragment mVolume;
@SuppressWarnings("unused")
private InfoFragment mInfo;
private PlaylistFragment mPlaylist;
private BrowseFragment mBrowse;
private ServicesDiscoveryFragment mServicesDiscovery;
private NavigationFragment mNavigation;
private StatusFragment mStatus;
private VolumePanel mVolumePanel;
private BroadcastReceiver mStatusReceiver;
private int mVolumeLevel = VOLUME_LEVEL_UNKNOWN;
private int mLastNonZeroVolume = VOLUME_LEVEL_UNKNOWN;
private String mInput;
private SlidingDrawer mDrawer;
private ViewFlipper mFlipper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// Set the control stream to STREAM_MUSIC to suppress system beeps
// that sound even when the activity handles volume key events.
setVolumeControlStream(AudioManager.STREAM_MUSIC);
mStatus = findOrAddFragment(FRAGMENT_STATUS, StatusFragment.class);
mPlayback = findFragmentById(R.id.fragment_playback);
mArt = findFragmentById(R.id.fragment_art);
mButtons = findFragmentById(R.id.fragment_buttons);
mVolume = findFragmentById(R.id.fragment_volume);
mInfo = findFragmentById(R.id.fragment_info);
mPlaylist = findFragmentById(R.id.fragment_playlist);
mBrowse = findFragmentById(R.id.fragment_browse);
mServicesDiscovery = findFragmentById(R.id.fragment_services_discovery);
mNavigation = findFragmentById(R.id.fragment_navigation);
Context context = this;
mVolumePanel = new VolumePanel(context);
mTabHost = (TabHost) findViewById(android.R.id.tabhost);
if (mTabHost != null) {
mTabHost.setup();
addTab(TAB_MEDIA, R.id.tab_media, R.string.nowplaying_title, R.drawable.ic_tab_artists);
addTab(TAB_PLAYLIST, R.id.tab_playlist, R.string.tab_playlist,
R.drawable.ic_tab_playlists);
addTab(TAB_BROWSE, R.id.tab_browse, R.string.goto_start, R.drawable.ic_tab_playback);
addTab(TAB_NAVIGATION, R.id.tab_navigation, R.string.tab_dvd, R.drawable.ic_tab_albums);
mTabHost.setOnTabChangedListener(this);
onTabChanged(mTabHost.getCurrentTabTag());
} else {
onTabChanged(null);
}
mDrawer = (SlidingDrawer) findViewById(R.id.drawer);
if (mDrawer != null) {
assert Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
BrowseDrawerListener listener = new BrowseDrawerListener(this, mDrawer, mBrowse);
mDrawer.setOnDrawerOpenListener(listener);
mDrawer.setOnDrawerCloseListener(listener);
}
mFlipper = (ViewFlipper) findViewById(R.id.flipper);
Preferences preferences = Preferences.get(context);
String authority = preferences.getAuthority();
if (authority != null) {
changeServer(authority);
}
if (savedInstanceState == null) {
onNewIntent(getIntent());
}
}
@Override
public void onAttachFragment(Fragment fragment) {
super.onAttachFragment(fragment);
if (fragment instanceof HotkeyDialog) {
((HotkeyDialog) fragment).setHotkeyListener(this);
}
}
private void addTab(String tag, int content, int label, int icon) {
if (mTabHost.findViewById(content) != null) {
TabHost.TabSpec spec = mTabHost.newTabSpec(tag);
spec.setContent(content);
spec.setIndicator(getText(label), getResources().getDrawable(icon));
mTabHost.addTab(spec);
} else {
// Tab does not exist in this layout
}
}
/** {@inheritDoc} */
public void onTabChanged(String tabId) {
if (TAB_PLAYLIST.equals(tabId)) {
mPlaylist.selectCurrentTrack();
}
mPlaylist.setHasOptionsMenu(TAB_PLAYLIST.equals(tabId) || mTabHost == null);
mBrowse.setHasOptionsMenu(TAB_BROWSE.equals(tabId) && mDrawer == null);
if (Build.VERSION.SDK_INT > 11) {
try {
getClass().getMethod("invalidateOptionsMenu").invoke(this);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/** {@inheritDoc} */
public void onClick(View v) {
switch (v.getId()) {
case R.id.button_navigation:
mFlipper.showNext();
updateNavigationButton(v);
break;
}
}
/** {@inheritDoc} */
public void onHotkey(String keycode) {
if ("toggle-fullscreen".equals(keycode)) {
mMediaServer.status().command.fullscreen();
} else {
mMediaServer.status().command.key(keycode);
}
}
private void updateNavigationButton(View v) {
ImageButton button = (ImageButton) v;
boolean on = (mFlipper.getDisplayedChild() != 0);
int icon = on ? R.drawable.ic_navigation_on : R.drawable.ic_navigation_off;
button.setImageResource(icon);
}
@Override
public boolean onSearchRequested() {
String initialQuery = mInput;
boolean selectInitialQuery = true;
Bundle appSearchData = null;
boolean globalSearch = false;
startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch);
return true;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.playback_options, menu);
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
String tabId = mTabHost != null ? mTabHost.getCurrentTabTag() : null;
boolean visible = tabId == null || TAB_MEDIA.equals(tabId);
menu.findItem(R.id.menu_preferences).setVisible(visible);
menu.findItem(R.id.menu_help).setVisible(visible);
return menu.hasVisibleItems();
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_preferences:
pickServer();
return true;
case R.id.menu_help:
Intent intent = new Intent(Intent.ACTION_VIEW, URI_TROUBLESHOOTING);
intent.putExtra(Browser.EXTRA_APPLICATION_ID, getPackageName());
startActivity(intent);
return true;
default:
return super.onOptionsItemSelected(item);
}
}
private void pickServer() {
Preferences preferences = Preferences.get(this);
ArrayList<String> remembered = preferences.getRememberedServers();
Intent intent = new Intent(this, PickServerActivity.class);
intent.putExtra(PickServerActivity.EXTRA_PORT, 8080);
intent.putExtra(PickServerActivity.EXTRA_FILE, "/requests/status.xml");
intent.putStringArrayListExtra(PickServerActivity.EXTRA_REMEMBERED, remembered);
startActivityForResult(intent, REQUEST_PICK_SERVER);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case REQUEST_PICK_SERVER:
Preferences preferences = Preferences.get(this);
if (resultCode == RESULT_OK) {
String authority = data.getData().getAuthority();
changeServer(authority);
preferences.setAuthority(authority);
mBrowse.openDirectory("~");
}
if (data != null) {
// Update remembered servers even if
// (resultCode == RESULT_CANCELED)
String key = PickServerActivity.EXTRA_REMEMBERED;
ArrayList<String> remembered = data.getStringArrayListExtra(key);
if (remembered != null) {
preferences.setRemeberedServers(remembered);
}
}
if (mMediaServer == null) {
finish();
}
break;
default:
super.onActivityResult(requestCode, resultCode, data);
}
}
private void changeServer(String authority) {
Context context = this;
mMediaServer = new MediaServer(context, authority);
mPlayback.setMediaServer(mMediaServer);
mButtons.setMediaServer(mMediaServer);
mVolume.setMediaServer(mMediaServer);
if (mArt != null) {
mArt.setMediaServer(mMediaServer);
}
mPlaylist.setMediaServer(mMediaServer);
mBrowse.setMediaServer(mMediaServer);
mStatus.setMediaServer(mMediaServer);
if (mServicesDiscovery != null) {
mServicesDiscovery.setMediaServer(mMediaServer);
}
if (mNavigation != null) {
mNavigation.setMediaServer(mMediaServer);
}
}
@Override
protected void onNewIntent(Intent intent) {
String host = intent.getStringExtra(Intents.EXTRA_REMOTE_HOST);
if (host != null) {
int port = intent.getIntExtra(Intents.EXTRA_REMOTE_PORT, 8080);
String authority = host + ":" + port;
changeServer(authority);
}
String action = intent.getAction();
if (Intent.ACTION_VIEW.equals(action) || Intents.ACTION_REMOTE_VIEW.equals(action)
|| Intents.ACTION_VIEW.equals(action)) {
Uri data = intent.getData();
if (data != null) {
changeInput(data.toString());
}
} else if (Intent.ACTION_SEARCH.equals(action)) {
String input = intent.getStringExtra(SearchManager.QUERY);
changeInput(input);
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putString(STATE_INPUT, mInput);
if (mTabHost != null) {
outState.putString(STATE_TAB, mTabHost.getCurrentTabTag());
}
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
mInput = savedInstanceState.getString(STATE_INPUT);
if (mTabHost != null) {
mTabHost.setCurrentTabByTag(savedInstanceState.getString(STATE_TAB));
}
}
private void changeInput(String input) {
if (mMediaServer == null) {
Log.w(TAG, "No server selected");
return;
}
mInput = input;
if (mInput != null) {
mMediaServer.status().command.input.play(mInput);
}
}
@Override
public void onResume() {
super.onResume();
mStatusReceiver = new StatusReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(Intents.ACTION_STATUS);
registerReceiver(mStatusReceiver, filter);
if (mMediaServer == null) {
pickServer();
}
}
@Override
public void onPause() {
unregisterReceiver(mStatusReceiver);
mStatusReceiver = null;
super.onPause();
}
void onVolumeChanged(int volume) {
if (!hasVolumeFragment() && mVolumeLevel != VOLUME_LEVEL_UNKNOWN && mVolumeLevel != volume) {
mVolumePanel.onVolumeChanged(volume);
}
mVolumeLevel = volume;
if (0 != volume) {
mLastNonZeroVolume = volume;
}
}
private boolean hasVolumeFragment() {
return mVolume != null && mVolume.isInLayout();
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
int c = event.getUnicodeChar();
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
if (mVolumeLevel != VOLUME_LEVEL_UNKNOWN) {
setVolume(mVolumeLevel + 20);
} else {
mMediaServer.status().command.volumeUp();
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
if (mVolumeLevel != VOLUME_LEVEL_UNKNOWN) {
setVolume(mVolumeLevel - 20);
} else {
mMediaServer.status().command.volumeDown();
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
if (event.isAltPressed()) {
mMediaServer.status().command.seek(Uri.encode("-10"));
return true;
} else if (event.isShiftPressed()) {
mMediaServer.status().command.seek(Uri.encode("-3"));
return true;
} else {
mMediaServer.status().command.key("nav-left");
return true;
}
} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (event.isAltPressed()) {
mMediaServer.status().command.seek(Uri.encode("+10"));
return true;
} else if (event.isShiftPressed()) {
mMediaServer.status().command.seek(Uri.encode("+3"));
return true;
} else {
mMediaServer.status().command.key("nav-right");
return true;
}
} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
mMediaServer.status().command.key("nav-up");
return true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
mMediaServer.status().command.key("nav-down");
return true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
mMediaServer.status().command.key("nav-activate");
return true;
} else if (c == ' ') {
mMediaServer.status().command.playback.pause();
return true;
} else if (c == 's') {
mMediaServer.status().command.playback.stop();
return true;
} else if (c == 'p') {
mMediaServer.status().command.playback.previous();
return true;
} else if (c == 'n') {
mMediaServer.status().command.playback.next();
return true;
} else if (c == '+') {
// TODO: Play faster
return super.onKeyDown(keyCode, event);
} else if (c == '-') {
// TODO: Play slower
return super.onKeyDown(keyCode, event);
} else if (c == 'f') {
mMediaServer.status().command.fullscreen();
return true;
} else if (c == 'm') {
mute();
return true;
} else {
return super.onKeyDown(keyCode, event);
}
}
private void setVolume(int volume) {
volume = Math.max(volume, 0);
volume = Math.min(volume, MAX_VOLUME);
mMediaServer.status().command.volume(volume);
onVolumeChanged(volume);
}
private void mute() {
// The web interface doesn't have a documented mute command.
if (mVolumeLevel != 0) {
// Set the volume to zero
mMediaServer.status().command.volume(0);
} else if (mLastNonZeroVolume != VOLUME_LEVEL_UNKNOWN) {
// Restore the volume to the last known value
mMediaServer.status().command.volume(mLastNonZeroVolume);
}
}
@SuppressWarnings("unchecked")
private <T extends Fragment> T findFragmentById(int id) {
FragmentManager fragmentManager = getSupportFragmentManager();
return (T) fragmentManager.findFragmentById(id);
}
@SuppressWarnings("unchecked")
private <T extends Fragment> T findOrAddFragment(String tag, Class<T> fragmentClass) {
try {
FragmentManager fragmentManager = getSupportFragmentManager();
T fragment = (T) fragmentManager.findFragmentByTag(tag);
if (fragment == null) {
fragment = fragmentClass.newInstance();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.add(fragment, FRAGMENT_STATUS);
fragmentTransaction.commit();
fragmentManager.executePendingTransactions();
}
return fragment;
} catch (InstantiationException e) {
throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(e);
}
}
private class StatusReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intents.ACTION_STATUS.equals(action)) {
Status status = (Status) intent.getSerializableExtra(Intents.EXTRA_STATUS);
onVolumeChanged(status.getVolume());
}
}
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.app;
import org.peterbaldwin.client.android.vlcremote.R;
import org.peterbaldwin.vlcremote.fragment.BrowseFragment;
import android.app.Activity;
import android.view.ActionMode;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.SlidingDrawer;
final class BrowseDrawerListener implements SlidingDrawer.OnDrawerOpenListener,
SlidingDrawer.OnDrawerCloseListener {
private final Activity mActivity;
private final SlidingDrawer mDrawer;
private final BrowseFragment mBrowse;
private ActionMode mActionMode;
public BrowseDrawerListener(Activity activity, SlidingDrawer drawer, BrowseFragment browse) {
mActivity = activity;
mDrawer = drawer;
mBrowse = browse;
}
/** {@inheritDoc} */
public void onDrawerOpened() {
startActionMode();
mDrawer.getHandle().setVisibility(View.INVISIBLE);
}
/** {@inheritDoc} */
public void onDrawerClosed() {
finishActionMode();
mDrawer.getHandle().setVisibility(View.VISIBLE);
}
private void startActionMode() {
if (mActionMode == null) {
mActionMode = mActivity.startActionMode(new ActionModeCallback());
}
}
private void finishActionMode() {
if (mActionMode != null) {
mActionMode.finish();
mActionMode = null;
}
}
// BrowseDrawerListener can't be referenced by code running
// on Android 1.6 if it implements ActionMode.Callback directly,
// so implement ActionMode.Callback with a nested class instead.
private class ActionModeCallback implements ActionMode.Callback {
/** {@inheritDoc} */
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
return mBrowse.onOptionsItemSelected(item);
}
/** {@inheritDoc} */
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
mActivity.getMenuInflater().inflate(R.menu.browse_options, menu);
return true;
}
/** {@inheritDoc} */
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
return true;
}
/** {@inheritDoc} */
public void onDestroyActionMode(ActionMode mode) {
if (mode == mActionMode) {
if (mDrawer.isOpened()) {
mDrawer.animateClose();
}
mActionMode = null;
}
}
}
}
| Java |
/*-
* Copyright (C) 2009 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.app;
import org.peterbaldwin.client.android.vlcremote.R;
import org.peterbaldwin.vlcremote.preference.ProgressCategory;
import org.peterbaldwin.vlcremote.receiver.PhoneStateChangedReceiver;
import org.peterbaldwin.vlcremote.sweep.PortSweeper;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Looper;
import android.os.SystemClock;
import android.preference.CheckBoxPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.text.TextUtils;
import android.util.Log;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView.AdapterContextMenuInfo;
import android.widget.EditText;
import android.widget.ListAdapter;
import java.net.HttpURLConnection;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
public final class PickServerActivity extends PreferenceActivity implements PortSweeper.Callback,
DialogInterface.OnClickListener, OnPreferenceChangeListener {
private static final String TAG = "PickServer";
private static final String PACKAGE_NAME = R.class.getPackage().getName();
private static final ComponentName PHONE_STATE_RECEIVER = new ComponentName(PACKAGE_NAME,
PhoneStateChangedReceiver.class.getName());
public static final String EXTRA_PORT = "org.peterbaldwin.portsweep.intent.extra.PORT";
public static final String EXTRA_FILE = "org.peterbaldwin.portsweep.intent.extra.FILE";
public static final String EXTRA_WORKERS = "org.peterbaldwin.portsweep.intent.extra.WORKERS";
public static final String EXTRA_REMEMBERED = "org.peterbaldwin.portsweep.intent.extra.REMEMBERED";
private static final String KEY_WIFI = "wifi";
private static final String KEY_SERVERS = "servers";
private static final String KEY_ADD_SERVER = "add_server";
private static final String KEY_PAUSE_FOR_CALL = "pause_for_call";
public static final String STATE_HOSTS = "hosts";
public static final int DEFAULT_WORKERS = 16;
private static final int DIALOG_ADD_SERVER = 1;
private static final int MENU_SCAN = Menu.FIRST;
private static final int CONTEXT_FORGET = Menu.FIRST;
private static byte[] toByteArray(int i) {
int i4 = (i >> 24) & 0xFF;
int i3 = (i >> 16) & 0xFF;
int i2 = (i >> 8) & 0xFF;
int i1 = i & 0xFF;
return new byte[] {
(byte) i1, (byte) i2, (byte) i3, (byte) i4
};
}
private PortSweeper mPortSweeper;
private BroadcastReceiver mReceiver;
private AlertDialog mDialogAddServer;
private EditText mEditHostname;
private EditText mEditPort;
private EditText mEditUser;
private EditText mEditPassword;
private String mFile;
private int mPort;
private int mWorkers;
private long mCreateTime;
private ArrayList<String> mRemembered;
private CheckBoxPreference mPreferenceWiFi;
private CheckBoxPreference mPreferencePauseForCall;
private ProgressCategory mProgressCategory;
private Preference mPreferenceAddServer;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.server_settings);
PreferenceScreen preferenceScreen = getPreferenceScreen();
mPreferenceWiFi = (CheckBoxPreference) preferenceScreen.findPreference(KEY_WIFI);
mPreferencePauseForCall = (CheckBoxPreference) preferenceScreen.findPreference(KEY_PAUSE_FOR_CALL);
mProgressCategory = (ProgressCategory) preferenceScreen.findPreference(KEY_SERVERS);
mPreferenceAddServer = preferenceScreen.findPreference(KEY_ADD_SERVER);
mPreferencePauseForCall.setOnPreferenceChangeListener(this);
mPreferencePauseForCall.setChecked(getPauseForCall());
Intent intent = getIntent();
mPort = intent.getIntExtra(EXTRA_PORT, 0);
if (mPort == 0) {
throw new IllegalArgumentException("Port must be specified");
}
mFile = intent.getStringExtra(EXTRA_FILE);
if (mFile == null) {
throw new IllegalArgumentException("File must be specified");
}
mRemembered = intent.getStringArrayListExtra(EXTRA_REMEMBERED);
if (mRemembered == null) {
mRemembered = new ArrayList<String>();
}
registerForContextMenu(getListView());
mWorkers = intent.getIntExtra(EXTRA_WORKERS, DEFAULT_WORKERS);
mPortSweeper = (PortSweeper) getLastNonConfigurationInstance();
if (mPortSweeper == null) {
mPortSweeper = createPortSweeper();
startSweep();
}
mPortSweeper.setCallback(this);
// Registering the receiver triggers a broadcast with the initial state.
// To tell the difference between a broadcast triggered by registering a
// receiver and a broadcast triggered by a true network event, note the
// time and ignore all broadcasts for one second.
mCreateTime = SystemClock.uptimeMillis();
mReceiver = new MyBroadcastReceiver();
// For robustness, update the connection status for all types of events.
IntentFilter filter = new IntentFilter();
filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
registerReceiver(mReceiver, filter);
updateWifiInfo();
}
boolean isInitialBroadcast() {
return (SystemClock.uptimeMillis() - mCreateTime) < 1000;
}
@Override
public Object onRetainNonConfigurationInstance() {
Object nonConfigurationInstance = mPortSweeper;
// TODO: Set callback to null without triggering NullPointerException in
// the event that a callback happens while the Activity is recreating
// itself.
mPortSweeper = null;
return nonConfigurationInstance;
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
int n = mProgressCategory.getPreferenceCount();
ArrayList<String> hosts = new ArrayList<String>(n * 2);
for (int i = 0; i < n; i++) {
Preference preference = mProgressCategory.getPreference(i);
String hostname = preference.getTitle().toString();
String responseCode = preference.getKey();
if (!mRemembered.contains(hostname)) {
hosts.add(hostname);
hosts.add(responseCode);
}
}
outState.putStringArrayList(STATE_HOSTS, hosts);
}
private Preference createServerPreference(String server, int responseCode) {
Preference preference = new Preference(this);
preference.setKey(Integer.toString(responseCode));
preference.setTitle(server);
preference.setPersistent(false);
switch (responseCode) {
case HttpURLConnection.HTTP_FORBIDDEN:
preference.setSummary(getText(R.string.summary_forbidden));
break;
}
return preference;
}
@Override
protected void onRestoreInstanceState(Bundle state) {
super.onRestoreInstanceState(state);
List<String> hosts = state.getStringArrayList(STATE_HOSTS);
for (int i = 0; i < hosts.size(); i += 2) {
String hostname = hosts.get(i);
String key = hosts.get(i + 1);
int responseCode = (key != null) ? Integer.parseInt(key) : HttpURLConnection.HTTP_OK;
Preference preference = createServerPreference(hostname, responseCode);
mProgressCategory.addPreference(preference);
}
}
@Override
protected void onDestroy() {
unregisterReceiver(mReceiver);
mReceiver = null;
if (mPortSweeper != null) {
mPortSweeper.destory();
}
super.onDestroy();
}
private PortSweeper createPortSweeper() {
PortSweeper.Callback callback = this;
Looper looper = Looper.myLooper();
return new PortSweeper(mPort, mFile, mWorkers, callback, looper);
}
private WifiInfo getConnectionInfo() {
Object service = getSystemService(WIFI_SERVICE);
WifiManager manager = (WifiManager) service;
WifiInfo info = manager.getConnectionInfo();
if (info != null) {
SupplicantState state = info.getSupplicantState();
if (state.equals(SupplicantState.COMPLETED)) {
return info;
}
}
return null;
}
private byte[] getIpAddress() {
WifiInfo info = getConnectionInfo();
if (info != null) {
return toByteArray(info.getIpAddress());
}
return null;
}
void startSweep() {
byte[] ipAddress = getIpAddress();
if (ipAddress != null) {
mPortSweeper.sweep(ipAddress);
}
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onStop() {
super.onStop();
}
/** {@inheritDoc} */
public void onHostFound(String hostname, int responseCode) {
String server = hostname + ":" + mPort;
switch (responseCode) {
case HttpURLConnection.HTTP_OK:
case HttpURLConnection.HTTP_FORBIDDEN:
if (!mRemembered.contains(server)) {
Preference preference = createServerPreference(server, responseCode);
mProgressCategory.addPreference(preference);
}
break;
default:
Log.d(TAG, "Unexpected response code: " + responseCode);
break;
}
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case DIALOG_ADD_SERVER:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.add_server);
LayoutInflater inflater = getLayoutInflater();
View view = inflater.inflate(R.layout.add_server, null);
mEditHostname = (EditText) view.findViewById(R.id.edit_hostname);
mEditPort = (EditText) view.findViewById(R.id.edit_port);
mEditUser = (EditText) view.findViewById(R.id.edit_user);
mEditPassword = (EditText) view.findViewById(R.id.edit_password);
builder.setView(view);
builder.setPositiveButton(R.string.ok, this);
builder.setNegativeButton(R.string.cancel, this);
mDialogAddServer = builder.create();
return mDialogAddServer;
default:
return super.onCreateDialog(id);
}
}
/** {@inheritDoc} */
public void onClick(DialogInterface dialog, int which) {
if (dialog == mDialogAddServer) {
switch (which) {
case DialogInterface.BUTTON_POSITIVE:
String hostname = getHostname();
int port = getPort();
String user = getUser();
String password = getPassword();
StringBuilder server = new StringBuilder();
if (!TextUtils.isEmpty(user)) {
server.append(user).append(':').append(password).append('@');
}
server.append(hostname).append(':').append(port);
pick(server.toString());
break;
case DialogInterface.BUTTON_NEGATIVE:
dialog.dismiss();
break;
}
}
}
private void pick(String server) {
Intent data = new Intent();
Uri uri = Uri.parse("http://" + server);
data.setData(uri);
if (!mRemembered.contains(server)) {
mRemembered.add(server);
}
data.putStringArrayListExtra(EXTRA_REMEMBERED, mRemembered);
setResult(RESULT_OK, data);
finish();
}
private void forget(String server) {
mRemembered.remove(server);
int count = mProgressCategory.getPreferenceCount();
for (int i = 0; i < count; i++) {
Preference preference = mProgressCategory.getPreference(i);
if (server.equals(preference.getTitle().toString())) {
mProgressCategory.removePreference(preference);
break;
}
}
// Send the updated list of remembered servers even if the activity is
// canceled
Intent data = new Intent();
data.putStringArrayListExtra(EXTRA_REMEMBERED, mRemembered);
setResult(RESULT_CANCELED, data);
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
if (preference == mPreferenceAddServer) {
showDialog(DIALOG_ADD_SERVER);
return true;
} else if (preference == mPreferenceWiFi) {
Intent intent = new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK);
startActivity(intent);
// Undo checkbox toggle
updateWifiInfo();
return true;
} else if (preference == mPreferencePauseForCall) {
return super.onPreferenceTreeClick(preferenceScreen, preference);
} else {
String server = preference.getTitle().toString();
pick(server);
return true;
}
}
/** {@inheritDoc} */
public boolean onPreferenceChange(Preference preference, Object newValue) {
if (preference == mPreferencePauseForCall) {
setPauseForCall(Boolean.TRUE.equals(newValue));
return true;
} else {
return false;
}
}
private Preference getPreferenceFromMenuInfo(ContextMenuInfo menuInfo) {
if (menuInfo != null) {
if (menuInfo instanceof AdapterContextMenuInfo) {
AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
PreferenceScreen screen = getPreferenceScreen();
ListAdapter root = screen.getRootAdapter();
Object item = root.getItem(adapterMenuInfo.position);
return (Preference) item;
}
}
return null;
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
Preference preference = getPreferenceFromMenuInfo(menuInfo);
if (preference != null) {
String server = preference.getTitle().toString();
if (mRemembered.contains(server)) {
menu.add(Menu.NONE, CONTEXT_FORGET, Menu.NONE, R.string.context_forget);
}
}
}
@Override
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()) {
case CONTEXT_FORGET:
ContextMenuInfo menuInfo = item.getMenuInfo();
Preference preference = getPreferenceFromMenuInfo(menuInfo);
if (preference != null) {
String server = preference.getTitle().toString();
forget(server);
}
return true;
default:
return super.onContextItemSelected(item);
}
}
/** {@inheritDoc} */
public void onProgress(int progress, int max) {
if (progress == 0) {
mProgressCategory.removeAll();
for (String server : mRemembered) {
Preference preference = createServerPreference(server, HttpURLConnection.HTTP_OK);
preference.setSummary(R.string.summary_remembered);
mProgressCategory.addPreference(preference);
}
}
mProgressCategory.setProgress(progress != max);
}
private String getHostname() {
return mEditHostname.getText().toString();
}
private String getUser() {
return mEditUser.getText().toString();
}
private String getPassword() {
return mEditPassword.getText().toString();
}
private int getPort() {
String value = String.valueOf(mEditPort.getText());
if (!TextUtils.isEmpty(value)) {
try {
return Integer.parseInt(value);
} catch (NumberFormatException e) {
Log.w(TAG, "Invalid port number: " + value);
}
}
return mPort;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuItem scan = menu.add(0, MENU_SCAN, 0, R.string.scan);
scan.setIcon(R.drawable.ic_menu_scan_network);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_SCAN:
startSweep();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
private void updateWifiInfo() {
WifiInfo info = getConnectionInfo();
if (info != null) {
mPreferenceWiFi.setChecked(true);
String ssid = info.getSSID();
String template = getString(R.string.summary_wifi_connected);
Object[] objects = {
ssid != null ? ssid : ""
};
CharSequence summary = MessageFormat.format(template, objects);
mPreferenceWiFi.setSummary(summary);
} else {
mPreferenceWiFi.setChecked(false);
mPreferenceWiFi.setSummary(R.string.summary_wifi_disconnected);
}
}
private boolean getPauseForCall() {
switch (getPackageManager().getComponentEnabledSetting(PHONE_STATE_RECEIVER)) {
case PackageManager.COMPONENT_ENABLED_STATE_DEFAULT:
case PackageManager.COMPONENT_ENABLED_STATE_ENABLED:
return true;
default:
return false;
}
}
private void setPauseForCall(boolean enabled) {
getPackageManager().setComponentEnabledSetting(
PHONE_STATE_RECEIVER,
enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED
: PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
PackageManager.DONT_KILL_APP);
}
private class MyBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
Bundle extras = intent.getExtras();
if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
NetworkInfo networkInfo = extras.getParcelable(WifiManager.EXTRA_NETWORK_INFO);
NetworkInfo.State state = networkInfo.getState();
if (state == NetworkInfo.State.CONNECTED) {
if (isInitialBroadcast()) {
// Don't perform a sweep if the broadcast was triggered
// as a result of a receiver being registered.
} else {
startSweep();
}
}
}
updateWifiInfo();
}
}
}
| Java |
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Modifications:
* -Connect to VLC server instead of media service
* -Listen for VLC status events
* -Schedule status updates for time at which current track is expected to end
*/
package org.peterbaldwin.vlcremote.appwidget;
import org.peterbaldwin.client.android.vlcremote.R;
import org.peterbaldwin.vlcremote.intent.Intents;
import org.peterbaldwin.vlcremote.model.Preferences;
import org.peterbaldwin.vlcremote.model.Status;
import org.peterbaldwin.vlcremote.model.Track;
import org.peterbaldwin.vlcremote.net.MediaServer;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.os.SystemClock;
import android.text.TextUtils;
import android.view.View;
import android.widget.RemoteViews;
/**
* Simple widget to show currently playing album art along with play/pause and
* next track buttons.
*/
public class MediaAppWidgetProvider extends AppWidgetProvider {
static final String LOG_TAG = "VlcRemoteAppWidgetProvider";
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intents.ACTION_STATUS.equals(action)) {
Status status = (Status) intent.getSerializableExtra(Intents.EXTRA_STATUS);
String noMedia = context.getString(R.string.no_media);
String text1;
String text2;
if (status.isStopped()) {
text1 = noMedia;
text2 = "";
} else {
Track track = status.getTrack();
text1 = track.getTitle();
text2 = track.getArtist();
if (TextUtils.isEmpty(text1) && TextUtils.isEmpty(text2)) {
text1 = track.getName();
}
}
int[] appWidgetIds = null;
performUpdate(context, text1, text2, status.isPlaying(), appWidgetIds);
long time = status.getTime();
long length = status.getLength();
if (status.isPlaying() && time >= 0L && length > 0L && time <= length) {
// Schedule an update shortly after the current track is
// expected to end.
long delay = length - time + 1000;
scheduleUpdate(context, delay);
}
} else if (Intents.ACTION_ERROR.equals(action)) {
CharSequence text1 = context.getText(R.string.connection_error);
Throwable t = (Throwable) intent.getSerializableExtra(Intents.EXTRA_THROWABLE);
String text2 = t.getMessage();
if (text2 == null) {
text2 = t.getClass().getName();
}
Boolean playing = null;
int[] appWidgetIds = null;
performUpdate(context, text1, text2, playing, appWidgetIds);
cancelPendingUpdate(context);
} else if (Intents.ACTION_MANUAL_APPWIDGET_UPDATE.equals(action)
|| ConnectivityManager.CONNECTIVITY_ACTION.equals(action)) {
int[] appWidgetIds = null;
update(context, appWidgetIds);
} else {
super.onReceive(context, intent);
}
}
private static PendingIntent createManualAppWidgetUpdateIntent(Context context) {
int requestCode = 0;
Intent intent = new Intent(Intents.ACTION_MANUAL_APPWIDGET_UPDATE);
int flags = 0;
return PendingIntent.getBroadcast(context, requestCode, intent, flags);
}
private void scheduleUpdate(Context context, long delay) {
Object service = context.getSystemService(Context.ALARM_SERVICE);
AlarmManager alarmManager = (AlarmManager) service;
int type = AlarmManager.ELAPSED_REALTIME_WAKEUP;
long triggerAtTime = SystemClock.elapsedRealtime() + delay;
PendingIntent operation = createManualAppWidgetUpdateIntent(context);
alarmManager.set(type, triggerAtTime, operation);
}
private void cancelPendingUpdate(Context context) {
Object service = context.getSystemService(Context.ALARM_SERVICE);
AlarmManager alarmManager = (AlarmManager) service;
PendingIntent operation = createManualAppWidgetUpdateIntent(context);
alarmManager.cancel(operation);
}
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetIds);
}
private void update(Context context, int[] appWidgetIds) {
Preferences preferences = Preferences.get(context);
String authority = preferences.getAuthority();
if (authority != null) {
MediaServer server = new MediaServer(context, authority);
server.status().get();
} else {
CharSequence text1 = context.getText(R.string.noserver);
CharSequence text2 = "";
Boolean playing = null;
performUpdate(context, text1, text2, playing, appWidgetIds);
}
}
private void pushUpdate(Context context, int[] appWidgetIds, RemoteViews views) {
// Update specific list of appWidgetIds if given,
// otherwise default to all
AppWidgetManager manager = AppWidgetManager.getInstance(context);
if (appWidgetIds != null) {
manager.updateAppWidget(appWidgetIds, views);
} else {
Class<? extends AppWidgetProvider> cls = getClass();
ComponentName provider = new ComponentName(context, cls);
manager.updateAppWidget(provider, views);
}
}
/**
* Update all active widget instances by pushing changes
*/
void performUpdate(Context context, CharSequence title, CharSequence artist, Boolean playing,
int[] appWidgetIds) {
String packageName = context.getPackageName();
RemoteViews views = new RemoteViews(packageName, R.layout.album_appwidget);
views.setViewVisibility(R.id.title, View.VISIBLE);
views.setTextViewText(R.id.title, title);
views.setTextViewText(R.id.artist, artist);
if (playing != null) {
views.setImageViewResource(R.id.control_play,
playing ? R.drawable.ic_appwidget_music_pause
: R.drawable.ic_appwidget_music_play);
} else {
views.setImageViewResource(R.id.control_play, R.drawable.ic_popup_sync_2);
}
views.setViewVisibility(R.id.control_next, playing != null ? View.VISIBLE : View.GONE);
// Link actions buttons to intents
linkButtons(context, views, playing);
pushUpdate(context, appWidgetIds, views);
}
/**
* Link up various button actions using {@link PendingIntent}.
*/
private void linkButtons(Context context, RemoteViews views, Boolean playing) {
{
int requestCode = 0;
Intent intent = getLaunchIntent(context);
int flags = 0;
PendingIntent pendingIntent = PendingIntent.getActivity(context, requestCode, intent,
flags);
views.setOnClickPendingIntent(R.id.album_appwidget, pendingIntent);
}
Preferences preferences = Preferences.get(context);
String authority = preferences.getAuthority();
if (authority == null) {
return;
}
MediaServer server = new MediaServer(context, authority);
if (playing != null) {
PendingIntent intent = server.status().command.playback.pendingPause();
views.setOnClickPendingIntent(R.id.control_play, intent);
} else {
PendingIntent intent = server.status().pendingGet();
views.setOnClickPendingIntent(R.id.control_play, intent);
}
{
PendingIntent intent = server.status().command.playback.pendingNext();
views.setOnClickPendingIntent(R.id.control_next, intent);
}
}
/**
* Returns the {@link Intent} to launch VLC Remote.
*/
private static Intent getLaunchIntent(Context context) {
return context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.net;
import org.apache.http.Header;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.protocol.HTTP;
import org.peterbaldwin.vlcremote.intent.Intents;
import org.peterbaldwin.vlcremote.model.Directory;
import org.peterbaldwin.vlcremote.model.Playlist;
import org.peterbaldwin.vlcremote.model.Remote;
import org.peterbaldwin.vlcremote.model.Status;
import org.peterbaldwin.vlcremote.service.StatusService;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.SystemClock;
import android.util.Log;
import java.io.IOException;
import java.net.ContentHandler;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public final class MediaServer {
private static final String TAG = "VLC";
private final Context mContext;
private final String mAuthority;
public MediaServer(Context context, String authority) {
mContext = context;
mAuthority = authority;
}
public MediaServer(Context context, Uri data) {
mContext = context;
mAuthority = data.getAuthority();
}
public String getAuthority() {
return mAuthority;
}
public StatusRequest status() {
return new StatusRequest(mContext, mAuthority);
}
public StatusRequest status(Uri uri) {
return new StatusRequest(mContext, uri);
}
public PlaylistRequest playlist(String search) {
return new PlaylistRequest(mContext, mAuthority, search);
}
public BrowseRequest browse(String dir) {
return new BrowseRequest(mContext, mAuthority, dir);
}
public ImageRequest image(Uri uri) {
return new ImageRequest(mContext, uri);
}
public ImageRequest art() {
return new ImageRequest(mContext, mAuthority);
}
static class Request {
/**
* Time to wait between network requests when sending multiple commands.
*/
protected static final int DELAY = 500;
private final Context mContext;
private final Uri mUri;
protected int mFlags;
protected boolean mNotifyPlaylist;
protected long mDelay;
protected Request(Context context, String authority, String path) {
mContext = context;
mUri = Uri.parse("http://" + authority + path);
}
protected Request(Context context, Uri uri) {
mContext = context;
mUri = uri;
}
protected final Intent intent(String encodedQuery) {
Intent intent = new Intent(Intents.ACTION_STATUS);
intent.setClass(mContext, StatusService.class);
Uri data = mUri.buildUpon().encodedQuery(encodedQuery).build();
intent.setData(data);
intent.putExtra(Intents.EXTRA_FLAGS, mFlags);
return intent;
}
protected final PendingIntent pending(Intent intent) {
return PendingIntent.getService(mContext, 0, intent, 0);
}
protected final void start(Intent intent) {
if (mDelay == 0L) {
mContext.startService(intent);
} else {
Object service = mContext.getSystemService(Context.ALARM_SERVICE);
AlarmManager manager = (AlarmManager) service;
long triggerAtTime = SystemClock.elapsedRealtime() + mDelay;
int requestCode = (int) triggerAtTime;
int flags = 0;
PendingIntent op = PendingIntent.getService(mContext, requestCode, intent, flags);
manager.set(AlarmManager.ELAPSED_REALTIME, triggerAtTime, op);
}
}
protected final void execute(String encodedQuery) {
start(intent(encodedQuery));
}
protected final <T> Remote<T> load(ContentHandler handler) {
String spec = mUri.toString();
try {
T data = read(handler);
return Remote.data(data);
} catch (Throwable t) {
Log.e(TAG, "Unable to load: " + spec, t);
return Remote.error(t);
}
}
@SuppressWarnings("unchecked")
protected final <T> T read(ContentHandler handler) throws IOException {
String spec = mUri.toString();
URL url = new URL(spec);
HttpURLConnection http = (HttpURLConnection) url.openConnection();
try {
String usernamePassword = mUri.getUserInfo();
if (usernamePassword != null) {
Header authorization = BasicScheme.authenticate(
new UsernamePasswordCredentials(usernamePassword), HTTP.UTF_8, false);
http.setRequestProperty(authorization.getName(), authorization.getValue());
}
return (T) handler.getContent(http);
} finally {
http.disconnect();
}
}
}
public static final class StatusRequest extends Request {
StatusRequest(Context context, String authority) {
super(context, authority, "/requests/status.xml");
}
public StatusRequest(Context context, Uri uri) {
super(context, uri);
}
public final CommandInterface command = new CommandInterface();
/**
* Loads the server status synchronously.
*/
public Remote<Status> load() {
return load(new StatusContentHandler());
}
public Status read() throws IOException {
return read(new StatusContentHandler());
}
/**
* Loads the server status asynchronously.
*/
public void get() {
execute("");
}
public PendingIntent pendingGet() {
return pending(intent(""));
}
public StatusRequest programmatic() {
mFlags |= Intents.FLAG_PROGRAMMATIC;
return this;
}
public StatusRequest onlyIfPlaying() {
mFlags |= Intents.FLAG_ONLY_IF_PLAYING;
return this;
}
public StatusRequest onlyIfPaused() {
mFlags |= Intents.FLAG_ONLY_IF_PAUSED;
return this;
}
public StatusRequest setResumeOnIdle() {
mFlags |= Intents.FLAG_SET_RESUME_ON_IDLE;
return this;
}
public final class CommandInterface {
public final InputInterface input = new InputInterface();
public class InputInterface {
private InputInterface() {
}
public void play(String input) {
List<String> options = Collections.emptyList();
play(input, options);
}
public void play(String input, String... options) {
play(input, Arrays.asList(options));
}
public void play(String input, List<String> options) {
// Options are appended to the MRL
// for VLC 1.1.10 and earlier
for (String option : options) {
input += " " + option;
}
String query = "command=in_play&input=" + Uri.encode(input);
// Options are appended as query parameters
// for VLC 1.1.11 and later
for (String option : options) {
query += ("&option=" + Uri.encode(option));
}
execute(query);
}
public void enqueue(String input) {
execute("command=in_enqueue&input=" + Uri.encode(input));
}
}
public final PlaybackInterface playback = new PlaybackInterface();
public class PlaybackInterface {
private PlaybackInterface() {
}
public void play(int id) {
execute("command=pl_play&id=" + id);
}
public void pause() {
execute("command=pl_pause");
}
public PendingIntent pendingPause() {
return pending(intent("command=pl_pause"));
}
public void stop() {
execute("command=pl_stop");
}
public void next() {
execute("command=pl_next");
}
public PendingIntent pendingNext() {
return pending(intent("command=pl_next"));
}
public void previous() {
execute("command=pl_previous");
}
public void delete(int id) {
mNotifyPlaylist = true;
execute("command=pl_delete&id=" + id);
}
public void empty() {
execute("command=pl_empty");
}
public void sort(int sort, int order) {
execute("command=pl_sort&id=" + order + "&val=" + sort);
}
public void shuffle() {
execute("command=pl_random");
}
public PlaybackInterface loop() {
execute("command=pl_loop");
mDelay += DELAY;
return this;
}
public PlaybackInterface repeat() {
execute("command=pl_repeat");
mDelay += DELAY;
return this;
}
public void random() {
execute("command=pl_random");
}
public void sd(String value) {
execute("command=pl_sd&val=" + value);
}
}
public void volume(int value) {
execute("command=volume&val=" + value);
}
public void adjustVolume(int amount) {
String val = amount < 0 ? Integer.toString(amount) : "+" + amount;
execute("command=volume&val=" + Uri.encode(val));
}
public void volumeDown() {
execute("command=volume&val=-20");
}
public void volumeUp() {
execute("command=volume&val=%2B20");
}
public void seek(String pos) {
execute("command=seek&val=" + pos);
}
public void key(String keycode) {
// Use hotkey name (without the "key-" part)
// as the argument to simulate a hotkey press
execute("command=key&val=" + keycode);
}
public void fullscreen() {
execute("command=fullscreen");
}
public void snapshot() {
execute("command=snapshot");
}
}
}
public static final class PlaylistRequest extends Request {
PlaylistRequest(Context context, String authority, String search) {
super(context, authority, "/requests/playlist.xml?search=" + Uri.encode(search));
}
public Remote<Playlist> load() {
return load(new PlaylistContentHandler());
}
}
public static final class BrowseRequest extends Request {
BrowseRequest(Context context, String authority, String dir) {
super(context, authority, "/requests/browse.xml?dir=" + Uri.encode(dir));
}
public Remote<Directory> load() {
return load(new DirectoryContentHandler());
}
}
public static final class ImageRequest extends Request {
ImageRequest(Context context, Uri uri) {
super(context, uri);
}
ImageRequest(Context context, String authority) {
super(context, authority, "/art");
}
public Bitmap read() throws IOException {
return read(new BitmapContentHandler());
}
public Remote<Bitmap> load() throws IOException {
return load(new BitmapContentHandler());
}
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.net;
import org.peterbaldwin.vlcremote.model.Directory;
import org.peterbaldwin.vlcremote.model.File;
import org.xml.sax.Attributes;
import android.sax.Element;
import android.sax.RootElement;
import android.sax.StartElementListener;
import java.io.IOException;
import java.net.URLConnection;
final class DirectoryContentHandler extends XmlContentHandler<Directory> {
private File createFile(Attributes attributes) {
String type = attributes.getValue("", "type");
String sizeString = attributes.getValue("", "size");
Long size = null;
try {
if (sizeString != null && !sizeString.equals("unknown")) {
size = Long.parseLong(sizeString);
}
} catch (NumberFormatException e) {
// Ignore unexpected value
}
String date = attributes.getValue("", "date");
String path = attributes.getValue("", "path");
String name = attributes.getValue("", "name");
String extension = attributes.getValue("", "extension");
if (path != null && !path.startsWith("/")) { // Windows path
// Work-around: Replace front-slash
// appended by server with back-slash.
path = path.replace('/', '\\');
}
return new File(type, size, date, path, name, extension);
}
@Override
public Object getContent(URLConnection connection) throws IOException {
final Directory directory = new Directory();
RootElement root = new RootElement("", "root");
Element element = root.getChild("", "element");
element.setStartElementListener(new StartElementListener() {
/** {@inheritDoc} */
public void start(Attributes attributes) {
File file = createFile(attributes);
directory.add(file);
}
});
parse(connection, root.getContentHandler());
return directory;
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.net;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* Work-around for <a
* href="http://code.google.com/p/android/issues/detail?id=6066">Issue 6066</a>
*/
final class BlockingFilterInputStream extends FilterInputStream {
public BlockingFilterInputStream(InputStream input) {
super(input);
}
@Override
public int read(byte[] buffer, int offset, int count) throws IOException {
int total = 0;
while (total < count) {
int read = super.read(buffer, offset + total, count - total);
if (read == -1) {
return (total != 0) ? total : -1;
}
total += read;
}
return total;
}
@Override
public int read(byte[] buffer) throws IOException {
int total = 0;
while (total < buffer.length) {
int offset = total;
int count = buffer.length - total;
int read = super.read(buffer, offset, count);
if (read == -1) {
return (total != 0) ? total : -1;
}
total += read;
}
return total;
}
@Override
public long skip(long count) throws IOException {
long total = 0L;
while (total < count) {
long skipped = super.skip(count - total);
if (skipped == 0L) {
int b = super.read();
if (b < 0) {
break;
} else {
skipped += 1;
}
}
total += skipped;
}
return total;
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.net;
import org.peterbaldwin.vlcremote.model.Playlist;
import org.peterbaldwin.vlcremote.model.Track;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import android.text.Html;
import java.io.IOException;
import java.net.URLConnection;
import java.util.Stack;
final class PlaylistContentHandler extends XmlContentHandler<Playlist> implements ContentHandler {
private static final String[] TEXT_ELEMENTS = {
"title", "artist", "genre", "copyright", "album", "track", "description", "rating",
"date", "url", "language", "now_playing", "publisher", "encoded_by", "art_url",
"track_id"
};
private static final Playlist EMPTY_PLAYLIST = new Playlist(1, "Undefined");
private final Stack<Playlist> mNodeStack;
private final StringBuilder mBuilder;
private Playlist mRoot;
private boolean mCapture = false;
private Track mTrack;
private boolean mFlatten = true;
public PlaylistContentHandler() {
mNodeStack = new Stack<Playlist>();
mBuilder = new StringBuilder();
}
/** {@inheritDoc} */
public void startElement(String uri, String localName, String name, Attributes attributes)
throws SAXException {
if ("leaf".equals(localName)) {
mTrack = createTrack(attributes);
if ("vlc://nop".equals(attributes.getValue("uri"))) {
// Don't include nop tracks in the output
} else {
if (mFlatten) {
mRoot.add(mTrack);
} else {
mNodeStack.peek().add(mTrack);
}
}
} else if ("node".equals(localName)) {
Playlist playlist = createPlaylist(attributes);
if (mNodeStack.isEmpty()) {
mRoot = playlist;
} else if (!mFlatten) {
mNodeStack.peek().add(playlist);
}
mNodeStack.push(playlist);
} else if (mTrack != null && isTextElement(localName)) {
mBuilder.setLength(0);
mCapture = true;
}
}
private static String unescape(CharSequence text) {
// TODO: Do this more efficiently
return Html.fromHtml(text.toString()).toString();
}
private String getText() {
if (mBuilder.length() == 0) {
return null;
} else {
if (mBuilder.indexOf("&") != -1) {
// Text is escaped twice so that it can be used in HTML.
return unescape(mBuilder);
} else {
return mBuilder.toString();
}
}
}
/** {@inheritDoc} */
public void endElement(String uri, String localName, String name) throws SAXException {
if ("node".equals(localName)) {
mNodeStack.pop();
} else if ("leaf".equals(localName)) {
mTrack = null;
} else if (mTrack != null) {
if ("title".equals(localName)) {
mTrack.setTitle(getText());
} else if ("artist".equals(localName)) {
mTrack.setArtist(getText());
} else if ("genre".equals(localName)) {
mTrack.setGenre(getText());
} else if ("copyright".equals(localName)) {
mTrack.setCopyright(getText());
} else if ("album".equals(localName)) {
mTrack.setAlbum(getText());
} else if ("track".equals(localName)) {
mTrack.setTrack(getText());
} else if ("description".equals(localName)) {
mTrack.setDescription(getText());
} else if ("rating".equals(localName)) {
mTrack.setRating(getText());
} else if ("date".equals(localName)) {
mTrack.setDate(getText());
} else if ("url".equals(localName)) {
mTrack.setUrl(getText());
} else if ("language".equals(localName)) {
mTrack.setLanguage(getText());
} else if ("now_playing".equals(localName)) {
mTrack.setNowPlaying(getText());
} else if ("publisher".equals(localName)) {
mTrack.setPublisher(getText());
} else if ("encoded_by".equals(localName)) {
mTrack.setEncodedBy(getText());
} else if ("art_url".equals(localName)) {
mTrack.setArtUrl(getText());
} else if ("track_id".equals(localName)) {
mTrack.setTrackId(getText());
}
}
mCapture = false;
}
private static boolean isTextElement(String localName) {
for (int i = 0; i < TEXT_ELEMENTS.length; i++) {
if (TEXT_ELEMENTS[i].equals(localName)) {
return true;
}
}
return false;
}
/** {@inheritDoc} */
public void characters(char[] ch, int start, int length) throws SAXException {
if (mCapture) {
mBuilder.append(ch, start, length);
}
}
/** {@inheritDoc} */
public void endDocument() throws SAXException {
}
/** {@inheritDoc} */
public void endPrefixMapping(String prefix) throws SAXException {
}
/** {@inheritDoc} */
public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
}
/** {@inheritDoc} */
public void processingInstruction(String target, String data) throws SAXException {
}
/** {@inheritDoc} */
public void setDocumentLocator(Locator locator) {
}
/** {@inheritDoc} */
public void skippedEntity(String name) throws SAXException {
}
/** {@inheritDoc} */
public void startDocument() throws SAXException {
}
/** {@inheritDoc} */
public void startPrefixMapping(String prefix, String uri) throws SAXException {
}
private static Playlist createPlaylist(Attributes attributes) {
int id = Integer.parseInt(attributes.getValue("", "id"));
String name = attributes.getValue("", "name");
return new Playlist(id, name);
}
private static Track createTrack(Attributes attributes) {
Track track = new Track();
int id = Integer.parseInt(attributes.getValue("", "id"));
track.setId(id);
boolean current = "current".equals(attributes.getValue("", "current"));
track.setCurrent(current);
String uri = attributes.getValue("", "uri");
track.setUri(uri);
String name = attributes.getValue("", "name");
track.setName(name);
long duration = Long.parseLong(attributes.getValue("", "duration"));
track.setDuration(duration);
return track;
}
@Override
public Object getContent(URLConnection connection) throws IOException {
parse(connection, this);
return (mRoot != null) ? mRoot : EMPTY_PLAYLIST;
}
}
| Java |
/*-
* Copyright (C) 2011 Peter Baldwin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.peterbaldwin.vlcremote.net;
import org.peterbaldwin.vlcremote.model.Status;
import org.peterbaldwin.vlcremote.model.Track;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import android.sax.Element;
import android.sax.ElementListener;
import android.sax.EndTextElementListener;
import android.sax.RootElement;
import android.sax.TextElementListener;
import android.text.Html;
import java.io.IOException;
import java.net.URLConnection;
final class StatusContentHandler extends XmlContentHandler<Status> {
private static String unescape(String text) {
// The response text is escaped twice so that it can be used in HTML.
if (text.indexOf("&") != -1) {
// TODO: Use more efficient unescaping
return Html.fromHtml(text.toString()).toString();
} else {
return text;
}
}
private static boolean parseBoolean(String text) {
try {
// Booleans are represented as integers in VLC 1.0
return Integer.parseInt(text) != 0;
} catch (NumberFormatException e) {
// Booleans are represented as strings in VLC 1.1
return Boolean.parseBoolean(text);
}
}
private Status mStatus = new Status();
private Track mTrack = mStatus.getTrack();
private String mCategoryName;
private String mInfoName;
public ContentHandler getContentHandler() {
RootElement root = new RootElement("", "root");
root.getChild("", "volume").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
int volume = Integer.parseInt(body);
mStatus.setVolume(volume);
}
});
root.getChild("", "length").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
int length = Integer.parseInt(body);
mStatus.setLength(length);
}
});
root.getChild("", "time").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
int time = Integer.parseInt(body);
mStatus.setTime(time);
}
});
root.getChild("", "state").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mStatus.setState(body);
}
});
root.getChild("", "position").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
double position = Double.parseDouble(body);
mStatus.setPosition(position);
}
});
root.getChild("", "fullscreen").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
boolean fullscreen = parseBoolean(body);
mStatus.setFullscreen(fullscreen);
}
});
root.getChild("", "random").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
boolean random = parseBoolean(body);
mStatus.setRandom(random);
}
});
root.getChild("", "loop").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
boolean loop = parseBoolean(body);
mStatus.setLoop(loop);
}
});
root.getChild("", "repeat").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
boolean repeat = parseBoolean(body);
mStatus.setRepeat(repeat);
}
});
Element information = root.getChild("", "information");
Element meta = information.getChild("", "meta-information");
meta.getChild("", "title").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setTitle(unescape(body));
}
});
meta.getChild("", "artist").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setArtist(unescape(body));
}
});
meta.getChild("", "genre").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setGenre(unescape(body));
}
});
meta.getChild("", "copyright").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setCopyright(unescape(body));
}
});
meta.getChild("", "album").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setAlbum(unescape(body));
}
});
meta.getChild("", "track").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setTrack(unescape(body));
}
});
meta.getChild("", "description").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setDescription(unescape(body));
}
});
meta.getChild("", "rating").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setRating(unescape(body));
}
});
meta.getChild("", "date").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setDate(unescape(body));
}
});
meta.getChild("", "url").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setUrl(unescape(body));
}
});
meta.getChild("", "language").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setLanguage(unescape(body));
}
});
meta.getChild("", "now_playing").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setNowPlaying(unescape(body));
}
});
meta.getChild("", "publisher").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setPublisher(unescape(body));
}
});
meta.getChild("", "encoded_by").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setEncodedBy(unescape(body));
}
});
meta.getChild("", "art_url").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setArtUrl(unescape(body));
}
});
meta.getChild("", "track_id").setEndTextElementListener(new EndTextElementListener() {
/** {@inheritDoc} */
public void end(String body) {
mTrack.setTrackId(unescape(body));
}
});
// VLC 1.1
Element category = information.getChild("", "category");
category.setElementListener(new ElementListener() {
/** {@inheritDoc} */
public void start(Attributes attributes) {
mCategoryName = attributes.getValue("", "name");
}
/** {@inheritDoc} */
public void end() {
mCategoryName = null;
}
});
Element info = category.getChild("", "info");
info.setTextElementListener(new TextElementListener() {
/** {@inheritDoc} */
public void start(Attributes attributes) {
mInfoName = attributes.getValue("", "name");
}
/** {@inheritDoc} */
public void end(String body) {
if ("meta".equalsIgnoreCase(mCategoryName)) {
if ("artist".equalsIgnoreCase(mInfoName)) {
mTrack.setArtist(unescape(body));
} else if ("title".equalsIgnoreCase(mInfoName)) {
mTrack.setTitle(unescape(body));
} else if ("album".equalsIgnoreCase(mInfoName)) {
mTrack.setAlbum(unescape(body));
} else if ("genre".equalsIgnoreCase(mInfoName)) {
mTrack.setGenre(unescape(body));
} else if ("description".equalsIgnoreCase(mInfoName)) {
mTrack.setDescription(unescape(body));
} else if ("filename".equalsIgnoreCase(mInfoName)) {
mTrack.setName(unescape(body));
} else if ("artwork_url".equalsIgnoreCase(mInfoName)) {
mTrack.setArtUrl(unescape(body));
}
}
mInfoName = null;
}
});
return root.getContentHandler();
}
@Override
public Object getContent(URLConnection connection) throws IOException {
parse(connection, getContentHandler());
return mStatus;
}
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.