/**
*
*/
package com.googlecode.flickr2twitter.datastore;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Query;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.appengine.api.datastore.Email;
import com.google.appengine.api.datastore.Key;
import com.googlecode.flickr2twitter.core.GlobalDefaultConfiguration;
import com.googlecode.flickr2twitter.core.ServiceRunner;
import com.googlecode.flickr2twitter.datastore.model.GlobalServiceConfiguration;
import com.googlecode.flickr2twitter.datastore.model.GlobalSourceApplicationService;
import com.googlecode.flickr2twitter.datastore.model.GlobalTargetApplicationService;
import com.googlecode.flickr2twitter.datastore.model.User;
import com.googlecode.flickr2twitter.datastore.model.UserServiceConfig;
import com.googlecode.flickr2twitter.datastore.model.UserSourceServiceConfig;
import com.googlecode.flickr2twitter.datastore.model.UserTargetServiceConfig;
/**
* @author Toby Yu(yuyang226@gmail.com)
*
*/
public final class MyPersistenceManagerFactory {
private static final PersistenceManagerFactory pmfInstance = JDOHelper
.getPersistenceManagerFactory("transactions-optional");
private static final Logger log = LoggerFactory
.getLogger(MyPersistenceManagerFactory.class);
public static enum Permission {
ADMIN, NORMAL
}
/**
*
*/
private MyPersistenceManagerFactory() {
super();
}
public static PersistenceManagerFactory getInstance() {
return pmfInstance;
}
public static GlobalSourceApplicationService getGlobalSourceAppService(
String providerId) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(GlobalSourceApplicationService.class);
query.setFilter("providerId == id");
query.declareParameters("String id");
List<?> data = (List<?>) query.execute(providerId);
if (data != null && data.isEmpty() == false)
return (GlobalSourceApplicationService) data.get(0);
} catch (Exception e) {
log.warn(e.getLocalizedMessage(), e);
} finally {
pm.close();
}
return null;
}
public static GlobalTargetApplicationService getGlobalTargetAppService(
String providerId) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(GlobalTargetApplicationService.class);
query.setFilter("providerId == id");
query.declareParameters("String id");
List<?> data = (List<?>) query.execute(providerId);
if (data != null && data.isEmpty() == false)
return (GlobalTargetApplicationService) data.get(0);
} catch (Exception e) {
log.warn(e.getLocalizedMessage(), e);
} finally {
pm.close();
}
return null;
}
@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
public static User createNewUser(String userEmail, String password,
String screenName) {
return createNewUser(userEmail, password, screenName, Permission.NORMAL);
}
/**
* @param user
* the login user
* @param accessToken
* the access token of the service.
* @param type
* 0: Source service; 1: target service
*/
public static void enableDisableUserService(User user, String accessToken,
int type) throws Exception {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
javax.jdo.Query query = null;
if (type == 0) {
query = pm.newQuery(UserSourceServiceConfig.class);
} else {
query = pm.newQuery(UserTargetServiceConfig.class);
}
query.setFilter("serviceAccessToken == atoken");
query.declareParameters("String atoken");
List<UserServiceConfig> result = (List<UserServiceConfig>) query
.execute(accessToken);
if (result.isEmpty()) {
throw new Exception("Can not find this service.");
}
UserServiceConfig service = result.get(0);
service.setEnabled(!service.isEnabled());
pm.makePersistent(service);
if (type == 0) {
List<UserSourceServiceConfig> sources = user
.getSourceServices();
for (UserSourceServiceConfig src : sources) {
if (src.getServiceAccessToken().equals(accessToken)) {
src.setEnabled(!src.isEnabled());
}
}
} else {
List<UserTargetServiceConfig> targets = user
.getTargetServices();
for (UserTargetServiceConfig tgt : targets) {
if (tgt.getServiceAccessToken().equals(accessToken)) {
tgt.setEnabled(!tgt.isEnabled());
}
}
}
} finally {
pm.close();
}
}
public static void updateUserLoginTime(String userEmail, Date loginTime) throws Exception {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
javax.jdo.Query query = null;
query = pm.newQuery(User.class);
query.setFilter("userId == email");
query.declareParameters("String email");
List<User> result = (List<User>) query
.execute(userEmail);
if (result.isEmpty()) {
throw new Exception("Can not find this user->" + userEmail);
}
User user = result.get(0);
user.setLastLoginTime(loginTime);
pm.makePersistent(user);
} finally {
pm.close();
}
}
public static void updateLastSourceTime(UserSourceServiceConfig userConfig, Date lastUpdateTime) throws Exception {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
javax.jdo.Query query = null;
query = pm.newQuery(UserSourceServiceConfig.class);
query.setFilter("serviceAccessToken == atoken && userEmail == userEmailStr");
query.declareParameters("String atoken, String userEmailStr");
List<UserSourceServiceConfig> result = (List<UserSourceServiceConfig>) query
.execute(userConfig.getServiceAccessToken(), userConfig.getUserEmail());
if (result.isEmpty()) {
throw new Exception("Can not find this user source config->" + userConfig.getUserEmail());
}
UserSourceServiceConfig srcConfig = result.get(0);
Calendar past = Calendar.getInstance(TimeZone.getTimeZone(ServiceRunner.TIMEZONE_UTC));
past.setTimeInMillis(lastUpdateTime.getTime());
srcConfig.setLastUpdateTime(past.getTime());
pm.makePersistent(srcConfig);
} finally {
pm.close();
}
}
/**
* @param user
* the login user
* @param accessToken
* the access token of the service.
* @param type
* 0: Source service; 1: target service
*/
public static void deleteUserService(User user, String accessToken, int type)
throws Exception {
String userEmail = user.getUserId().getEmail();
log.info("Deleting user service of user " + userEmail);
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
javax.jdo.Query query = null;
if (type == 0) {
log.info("Deleting source...");
query = pm.newQuery(UserSourceServiceConfig.class);
} else {
query = pm.newQuery(UserTargetServiceConfig.class);
log.info("Deleting target service...");
}
query.setFilter("serviceAccessToken == atoken && userEmail == userEmailStr");
query.declareParameters("String atoken, String userEmailStr");
List<UserServiceConfig> result = (List<UserServiceConfig>) query
.execute(accessToken, userEmail);
if (result.isEmpty()) {
throw new Exception("Can not find this service.");
}
log.info("Deleting target service...");
UserServiceConfig service = result.get(0);
pm.deletePersistent(service);
if (type == 0) {
List<UserSourceServiceConfig> sources = user
.getSourceServices();
UserSourceServiceConfig delSource = null;
for (UserSourceServiceConfig src : sources) {
if (src.getServiceAccessToken().equals(accessToken)) {
delSource = src;
}
}
if (delSource != null) {
sources.remove(delSource);
}
} else {
UserTargetServiceConfig delTarget = null;
List<UserTargetServiceConfig> targets = user
.getTargetServices();
for (UserTargetServiceConfig tgt : targets) {
if (tgt.getServiceAccessToken().equals(accessToken)) {
delTarget = tgt;
}
}
targets.remove(delTarget);
}
} finally {
pm.close();
}
}
public static UserSourceServiceConfig addSourceServiceApp(String userEmail,
UserSourceServiceConfig srcService) {
return addSourceServiceApp(getUser(userEmail), srcService);
}
public static UserSourceServiceConfig addSourceServiceApp(User user,
UserSourceServiceConfig srcService) {
if (user == null) {
throw new IllegalArgumentException("Invalid user: " + user);
}
List<UserSourceServiceConfig> services = getUserSourceServices(user);
int index = services.indexOf(srcService);
if (index >= 0) {
return services.get(index);
}
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
user.addSourceService(srcService);
pm.makePersistent(user);
return srcService;
} finally {
pm.close();
}
}
public static UserTargetServiceConfig addTargetServiceApp(String userEmail,
UserTargetServiceConfig targetService) {
return addTargetServiceApp(getUser(userEmail), targetService);
}
public static UserTargetServiceConfig addTargetServiceApp(User user,
UserTargetServiceConfig targetService) {
if (user == null) {
throw new IllegalArgumentException("Invalid user: " + user);
}
List<UserTargetServiceConfig> services = getUserTargetServices(user);
int index = services.indexOf(targetService);
if (index >= 0) {
return services.get(index);
}
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
user.addTargetService(targetService);
pm.makePersistent(user);
return targetService;
} finally {
pm.close();
}
}
public static User createNewUser(String userEmail, String password,
String screenName, Permission permission) {
User user = getUser(userEmail);
if (user != null) {
log.warn("User already exist: {}", userEmail);
return user;
}
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
String encryptionPassword = MessageDigestUtil
.getSHAPassword(password);
user = new User(new Email(userEmail), encryptionPassword,
screenName);
user.setPermission(permission.name());
pm.makePersistent(user);
return user;
} catch (NoSuchAlgorithmException e) {
log.warn("Unable to create user!", e);
return null;
} finally {
pm.close();
}
}
public static User updateUserPassword(Key key, String newPassword) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
User user = pm.getObjectById(User.class, key);
String passwordE = MessageDigestUtil.getSHAPassword(newPassword);
user.setPassword(passwordE);
return user;
} catch (NoSuchAlgorithmException e) {
log.warn("Unable to change password!", e);
return null;
} finally {
pm.close();
}
}
public static User updateUserDisplayName(Key key, String newDisplayName) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
User user = pm.getObjectById(User.class, key);
user.setScreenName(newDisplayName);
return user;
} finally {
pm.close();
}
}
public static User getUser(String userEmail) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(User.class);
query.setFilter("userId == userEmailAddress");
query.declareParameters("String userEmailAddress");
List<?> data = (List<?>) query.execute(userEmail);
if (data != null && data.isEmpty() == false)
return (User) data.get(0);
} finally {
pm.close();
}
return null;
}
public static User getLoginUser(String userEmail, String password) {
return getLoginUser(userEmail, password, false);
}
public static User getOpenIdLoginUser(String userEmail) {
return getLoginUser(userEmail, null, true);
}
public static User getLoginUser(String userEmail, String password,
boolean openId) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
List<?> data = null;
if (openId == true) {
Query query = pm.newQuery(User.class);
query.setFilter("userId == userEmailAddress");
query.declareParameters("String userEmailAddress");
data = (List<?>) query.execute(userEmail);
} else {
String encryptionPassword = MessageDigestUtil
.getSHAPassword(password);
Query query = pm.newQuery(User.class);
query.setFilter("userId == userEmailAddress && password == userPassword");
query.declareParameters("String userEmailAddress, String userPassword");
data = (List<?>) query.execute(userEmail, encryptionPassword);
}
if (data != null && data.isEmpty() == false) {
User u = (User) data.get(0);
log.info("Get user [{}] from the persistent store.", u);
try {
updateUserLoginTime(u.getUserId().getEmail(),
Calendar.getInstance(TimeZone.getTimeZone(ServiceRunner.TIMEZONE_UTC)).getTime());
} catch (Exception e) {
log.warn("Failed to update the user("
+ u.getUserId().getEmail() +
")'s last login time=>", e);
}
return u;
}
} catch (NoSuchAlgorithmException e) {
log.warn("Unable to login because of NoSuchAlgorithmException. WTF???", e);
} finally {
pm.close();
}
return null;
}
public static List<User> getAllUsers() {
List<User> users = new ArrayList<User>();
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(User.class);
List<?> results = (List<?>) query.execute();
for (Object obj : results) {
User user = (User) obj;
users.add(user);
user.getSourceServices();
user.getTargetServices();
}
} finally {
pm.close();
}
for (User user : users) {
getUserSourceServices(user);
getUserTargetServices(user);
}
return users;
}
public static List<UserSourceServiceConfig> getUserSourceServices(
String userEmail) {
return getUserSourceServices(getUser(userEmail));
}
public static List<UserSourceServiceConfig> getUserSourceServices(User user) {
if (user == null) {
throw new IllegalArgumentException("Invalid user: " + user);
}
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(UserSourceServiceConfig.class);
query.setFilter("userEmail == userEmailAddress");
query.declareParameters("String userEmailAddress");
List<?> data = (List<?>) query.execute(user.getUserId().getEmail());
if (data != null) {
for (Object o : data) {
if (user.getSourceServices().contains(o) == false) {
user.addSourceService((UserSourceServiceConfig) o);
}
}
}
} finally {
pm.close();
}
return user.getSourceServices();
}
public static List<UserTargetServiceConfig> getUserTargetServices(
String userEmail) {
return getUserTargetServices(getUser(userEmail));
}
public static List<UserTargetServiceConfig> getUserTargetServices(User user) {
if (user == null) {
throw new IllegalArgumentException("Invalid user: " + user);
}
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(UserTargetServiceConfig.class);
query.setFilter("userEmail == userEmailAddress");
query.declareParameters("String userEmailAddress");
List<?> data = (List<?>) query.execute(user.getUserId().getEmail());
if (data != null) {
for (Object o : data) {
if (user.getTargetServices().contains(o) == false) {
user.addTargetService((UserTargetServiceConfig) o);
}
}
}
} finally {
pm.close();
}
return user.getTargetServices();
}
public static GlobalServiceConfiguration getGlobalConfiguration() {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
GlobalServiceConfiguration conf = null;
try {
Query query = pm.newQuery(GlobalServiceConfiguration.class);
List<?> results = (List<?>) query.execute();
if (results.isEmpty() == false) {
conf = (GlobalServiceConfiguration) results.get(0);
} else {
conf = new GlobalServiceConfiguration();
conf.setKey("1");
conf.setMinUploadTime(GlobalDefaultConfiguration.getInstance()
.getInterval());
pm.makePersistent(conf);
}
} finally {
pm.close();
}
return conf;
}
public static boolean deleteOldUserTargetSource(String userServiceID,
String userEmail) {
PersistenceManagerFactory pmf = MyPersistenceManagerFactory
.getInstance();
PersistenceManager pm = pmf.getPersistenceManager();
try {
Query query = pm.newQuery(UserTargetServiceConfig.class);
query.setFilter("serviceUserId == currentServiceUserID && userEmail == userEmailAddress");
query.declareParameters("String currentServiceUserID, String userEmailAddress");
List<?> data = (List<?>) query.execute(userServiceID, userEmail);
if (data != null) {
log.info("Found target service:" + data.size());
pm.deletePersistentAll(data);
log.info("Target Service deleted.");
return true;
}
return false;
} finally {
pm.close();
}
}
}