You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
459 lines
16 KiB
459 lines
16 KiB
package kr.co.kihyun.sync; |
|
|
|
import java.util.ArrayList; |
|
import java.util.HashSet; |
|
import java.util.Iterator; |
|
import java.util.List; |
|
import java.util.MissingResourceException; |
|
import java.util.Set; |
|
|
|
import javax.jdo.Extent; |
|
import javax.jdo.PersistenceManager; |
|
import javax.jdo.Query; |
|
import javax.jdo.Transaction; |
|
|
|
import kr.co.kihyun.beans.entity.HandySync; |
|
import kr.co.kihyun.beans.entity.MDept; |
|
import kr.co.kihyun.beans.entity.MUser; |
|
import kr.co.kihyun.beans.entity.Role; |
|
import kr.co.kihyun.beans.entity.UserDept; |
|
import kr.co.kihyun.beans.entity.UserPart; |
|
import kr.co.kihyun.beans.entity.UserUser; |
|
import kr.co.kihyun.beans.entity.util.*; |
|
import kr.co.kihyun.lang.MInteger; |
|
import kr.co.kihyun.moumi.MoumiConfig; |
|
|
|
import org.slf4j.Logger; |
|
import org.slf4j.LoggerFactory; |
|
|
|
import com.handysoft.beans.entity.HDept; |
|
import com.handysoft.beans.entity.HDocUnit; |
|
import com.handysoft.beans.entity.HUser; |
|
import com.handysoft.beans.entity.HUserDept; |
|
import com.handysoft.beans.entity.HUserPart; |
|
import com.handysoft.beans.entity.HUserUser; |
|
import com.handysoft.beans.entity.HandyEntity; |
|
|
|
// TODO: extract method |
|
public class OrgSynchronizer extends Thread { |
|
private static final Logger LOG = LoggerFactory.getLogger(OrgSynchronizer.class); |
|
|
|
private boolean isDone = false; |
|
private int deptCapacity; |
|
private int userCapacity; |
|
private int userPartCapacity; |
|
private int userDeptCapacity; |
|
private int userUserCapacity; |
|
private Extent<HDept> hDeptExtent; |
|
private Extent<HUser> hUserExtent; |
|
private Extent<HDocUnit> hReceiverExtent; |
|
private Extent<MDept> mDeptExtent; |
|
private Extent<HUserPart> hUserPartExtent; |
|
private Extent<HUserDept> hUserDeptExtent; |
|
private Extent<HUserUser> hUserUserExtent; |
|
private Extent<UserPart> mUserPartExtent; |
|
private Extent<UserDept> mUserDeptExtent; |
|
private Extent<UserUser> mUserUserExtent; |
|
private PersistenceManager moumiPM; |
|
private PersistenceManager handyPM; |
|
|
|
|
|
private static final String SYNC = "SYNC"; //20.검사시점과 사용시점(멀티쓰레드)_CWE-367 : Add by KWON,HAN +++ |
|
|
|
|
|
public void done() { |
|
this.isDone = true; |
|
} |
|
|
|
@Override |
|
public void run() { |
|
synchronized(SYNC){ //20.검사시점과 사용시점(멀티쓰레드)_CWE-367 : Add by KWON,HAN +++ |
|
try { |
|
userPartCapacity = MInteger.parseInt(MoumiConfig.getInitParameter("moumi.initialUserPartCapacity"), 1500); |
|
} catch (MissingResourceException mre) { |
|
userPartCapacity = 1500; |
|
} |
|
try { |
|
userDeptCapacity = MInteger.parseInt(MoumiConfig.getInitParameter("moumi.initialUserDeptCapacity"), 200); |
|
} catch (MissingResourceException mre) { |
|
userDeptCapacity = 200; |
|
} |
|
try { |
|
userUserCapacity = MInteger.parseInt(MoumiConfig.getInitParameter("moumi.initialUserUserCapacity"), 30000); |
|
} catch (MissingResourceException mre) { |
|
userUserCapacity = 30000; |
|
} |
|
try { |
|
deptCapacity = MInteger.parseInt(MoumiConfig.getInitParameter("moumi.initialDeptCapacity"), 600); |
|
} catch (MissingResourceException mre) { |
|
deptCapacity = 600; |
|
} |
|
try { |
|
userCapacity = MInteger.parseInt(MoumiConfig.getInitParameter("moumi.initialUserCapacity"), 2000); |
|
} catch (MissingResourceException mre) { |
|
userCapacity = 2000; |
|
} |
|
|
|
while (!this.isDone) { |
|
moumiPM = new MPersistenceManager(PMF.get().getPersistenceManager()); |
|
handyPM = PMF.get("HANDY").getPersistenceManager(); |
|
Transaction moumiTx = moumiPM.currentTransaction(); |
|
Transaction handyTx = handyPM.currentTransaction(); |
|
try { |
|
LOG.info("getting extents has been started."); |
|
getExtents(); |
|
LOG.info("getting extents ended."); |
|
|
|
handyTx.begin(); |
|
LOG.info("handy scanning has been started."); |
|
LOG.debug("dept scanning has been started."); |
|
List<MDept> mDepts = getDepts(); |
|
LOG.debug("dept scanning ended."); |
|
LOG.debug("user scanning has been started."); |
|
List<MUser> mUsers = getUsers(); |
|
LOG.debug("user scanning ended."); |
|
LOG.debug("user part scanning has been started."); |
|
List<UserPart> mUserParts = getUserParts(); |
|
LOG.debug("user part scanning ended."); |
|
LOG.debug("user dept scanning has been started."); |
|
List<UserDept> mUserDepts = getUserDepts(); |
|
LOG.debug("user dept scanning ended."); |
|
LOG.debug("user user scanning has been started."); |
|
List<UserUser> mUserUsers = getUserUsers(); |
|
LOG.debug("user user scanning ended."); |
|
List<UserUser> deletedUserUserList = getDeletedList(hUserUserExtent, mUserUserExtent); |
|
List<UserDept> deletedUserDeptList = getDeletedList(hUserDeptExtent, mUserDeptExtent); |
|
List<UserPart> deletedUserPartList = getDeletedList(hUserPartExtent, mUserPartExtent); |
|
LOG.info("handy scanning ended."); |
|
handyTx.commit(); |
|
|
|
StringBuilder deletedUserSB = new StringBuilder(); |
|
for (UserUser deletedUser : deletedUserUserList) |
|
deletedUserSB.append(",").append(deletedUser); |
|
LOG.debug("{} will be deleted.", deletedUserSB); |
|
|
|
moumiTx.begin(); |
|
LOG.info("moumi persisting has been started."); |
|
LOG.debug("dept persisting has been started."); |
|
moumiPM.makePersistentAll(mDepts); |
|
LOG.debug("dept persisting ended."); |
|
LOG.debug("user persisting has been started."); |
|
moumiPM.makePersistentAll(mUsers); |
|
LOG.debug("user persisting ended."); |
|
moumiTx.commit(); |
|
moumiTx.begin(); |
|
LOG.debug("user part persisting has been started."); |
|
moumiPM.makePersistentAll(mUserParts); |
|
LOG.debug("user part persisting ended."); |
|
LOG.debug("user dept persisting has been started."); |
|
moumiPM.makePersistentAll(mUserDepts); |
|
LOG.debug("user dept persisting ended."); |
|
LOG.debug("user user persisting has been started."); |
|
moumiPM.makePersistentAll(mUserUsers); |
|
LOG.debug("user user persisting ended."); |
|
moumiPM.deletePersistentAll(deletedUserUserList); |
|
for (UserUser userUser : deletedUserUserList) |
|
LOG.debug("{} deleted.", userUser); |
|
moumiPM.deletePersistentAll(deletedUserDeptList); |
|
for (UserDept userDept : deletedUserDeptList) |
|
LOG.debug("{} deleted.", userDept); |
|
moumiPM.deletePersistentAll(deletedUserPartList); |
|
for (UserPart userPart : deletedUserPartList) |
|
LOG.debug("{} deleted.", userPart); |
|
LOG.debug("empty group deleting has been started."); |
|
StringBuilder deletedUserParts = new StringBuilder(1024); |
|
LOG.debug("these empty user_parts will be removed: {}", deletedUserParts); |
|
LOG.debug("empty group deleting ended."); |
|
LOG.info("moumi persisting ended."); |
|
moumiTx.commit(); |
|
|
|
OrgSynchronizer.sleep(1000); |
|
} catch (InterruptedException e) { |
|
e.printStackTrace(); |
|
} catch (Exception e) { |
|
e.printStackTrace(); |
|
} finally { |
|
if (handyTx.isActive()) |
|
handyTx.rollback(); |
|
if (moumiTx.isActive()) |
|
moumiTx.rollback(); |
|
moumiPM.close(); |
|
handyPM.close(); |
|
} |
|
} |
|
} //20.검사시점과 사용시점(멀티쓰레드)_CWE-367 : Add by KWON,HAN +++ |
|
} |
|
|
|
private void getExtents() { |
|
LOG.info("getting hDeptExtent has been started."); |
|
hDeptExtent = handyPM.getExtent(HDept.class, false); |
|
LOG.info("getting hDeptExtent ended."); |
|
LOG.info("getting hUserExtent has been started."); |
|
hUserExtent = handyPM.getExtent(HUser.class, false); |
|
LOG.info("getting hUserExtent ended."); |
|
LOG.info("getting hReceiverExtent has been started."); |
|
hReceiverExtent = handyPM.getExtent(HDocUnit.class, false); |
|
LOG.info("getting hReceiverExtent ended."); |
|
LOG.info("getting mDeptExtent has been started."); |
|
mDeptExtent = moumiPM.getExtent(MDept.class, false); |
|
LOG.info("getting mDeptExtent ended."); |
|
LOG.info("getting hUserPartExtent has been started."); |
|
hUserPartExtent = handyPM.getExtent(HUserPart.class, false); |
|
LOG.info("getting hUserPartExtent ended."); |
|
LOG.info("getting hUserDeptExtent has been started."); |
|
hUserDeptExtent = handyPM.getExtent(HUserDept.class, false); |
|
LOG.info("getting hUserDeptExtent ended."); |
|
LOG.info("getting hUserUserExtent has been started."); |
|
hUserUserExtent = handyPM.getExtent(HUserUser.class, false); |
|
LOG.info("getting hUserUserExtent ended."); |
|
LOG.info("getting mUserPartExtent has been started."); |
|
mUserPartExtent = moumiPM.getExtent(UserPart.class, false); |
|
LOG.info("getting mUserPartExtent ended."); |
|
LOG.info("getting mUserDeptExtent has been started."); |
|
mUserDeptExtent = moumiPM.getExtent(UserDept.class, false); |
|
LOG.info("getting mUserDeptExtent ended."); |
|
LOG.info("getting mUserUserExtent has been started."); |
|
mUserUserExtent = moumiPM.getExtent(UserUser.class, false); |
|
LOG.info("getting mUserUserExtent ended."); |
|
} |
|
|
|
private List<UserPart> getUserParts() { |
|
List<UserPart> mUserParts = new ArrayList<UserPart>(userPartCapacity); |
|
|
|
for (Iterator<HUserPart> userPartIter = hUserPartExtent.iterator(); userPartIter.hasNext();) { |
|
HUserPart hUserPart = userPartIter.next(); |
|
|
|
Query q = moumiPM.newQuery(mUserPartExtent, "handyId == handy_id"); |
|
q.declareParameters("String handy_id"); |
|
q.setUnique(true); |
|
UserPart mUserPart = (UserPart) q.execute(hUserPart.getId()); |
|
|
|
MUser owner = null; |
|
try { |
|
owner = moumiPM.getObjectById(MUser.class, "000000001".equals(hUserPart.getUserId()) ? "admin" |
|
: hUserPart.getUserId()); |
|
} catch (javax.jdo.JDOObjectNotFoundException jnfe) { |
|
// LOG.warn("{}'s owner MUser@{} is not exists. so this user part will be ignored.", |
|
// hUserPart, hUserPart.getUserId()); |
|
continue; |
|
} |
|
if (mUserPart == null) { |
|
mUserPart = new UserPart(hUserPart.getName(), owner, null); |
|
} |
|
|
|
mUserPart.setDescription(hUserPart.getDes()); |
|
mUserPart.setHandyId(hUserPart.getId()); |
|
mUserPart.setName(hUserPart.getName()); |
|
mUserPart.setUser(owner); |
|
|
|
mUserParts.add(mUserPart); |
|
} |
|
|
|
return mUserParts; |
|
} |
|
|
|
private <H extends HandyEntity, M extends HandySync> List<M> getDeletedList(Extent<H> handyExtent, |
|
Extent<M> moumiExtent) { |
|
List<M> deletedList = new ArrayList<M>(5000); |
|
List<String> handyIds = new ArrayList<String>(); |
|
|
|
for (Iterator<H> handyIter = handyExtent.iterator(); handyIter.hasNext();) { |
|
H handy = handyIter.next(); |
|
handyIds.add(handy.getId()); |
|
} |
|
|
|
for (Iterator<M> moumiIter = moumiExtent.iterator(); moumiIter.hasNext();) { |
|
M moumi = moumiIter.next(); |
|
if (!handyIds.contains(moumi.getHandyId())) |
|
deletedList.add(moumi); |
|
} |
|
|
|
return deletedList; |
|
} |
|
|
|
private List<UserDept> getUserDepts() { |
|
List<UserDept> mUserDepts = new ArrayList<UserDept>(userDeptCapacity); |
|
|
|
for (Iterator<HUserDept> userDeptIter = hUserDeptExtent.iterator(); userDeptIter.hasNext();) { |
|
HUserDept hUserDept = userDeptIter.next(); |
|
|
|
Query userPartQuery = moumiPM.newQuery(mUserPartExtent, "handyId == handy_id"); |
|
userPartQuery.declareParameters("String handy_id"); |
|
userPartQuery.setUnique(true); |
|
Query userDeptQuery = moumiPM.newQuery(mUserDeptExtent, "userPart == m_part && id == m_dept"); |
|
userDeptQuery.declareParameters("kr.co.kihyun.beans.entity.UserPart m_part, String m_dept"); |
|
userDeptQuery.setUnique(true); |
|
Query deptQuery = moumiPM.newQuery(mDeptExtent, "handyId == handy_id"); |
|
deptQuery.declareParameters("String handy_id"); |
|
deptQuery.setUnique(true); |
|
|
|
MDept mDept = (MDept) deptQuery.execute(hUserDept.getDeptId()); |
|
if (mDept == null) { |
|
// LOG.warn("MDept@{} is not exists. so this user dept will be ignored.", |
|
// hUserDept.getDeptId()); |
|
continue; |
|
} |
|
UserPart mUserPart = (UserPart) userPartQuery.execute(hUserDept.getPartId()); |
|
if (mUserPart == null) { |
|
// LOG.warn("UserPart@{} is not exists. so this user dept will be ignored.", |
|
// hUserDept.getPartId()); |
|
continue; |
|
} |
|
UserDept mUserDept = (UserDept) userDeptQuery.execute(mUserPart, mDept.getId()); |
|
if (mUserDept == null) { |
|
mUserDept = new UserDept(mDept, hUserDept.getName(), mUserPart); |
|
} |
|
|
|
mUserDept.setHandyId(hUserDept.getId()); |
|
mUserDept.setDept(mDept); |
|
mUserDept.setName(mDept.getName()); |
|
mUserDept.setUserPart(mUserPart); |
|
|
|
mUserDepts.add(mUserDept); |
|
} |
|
|
|
return mUserDepts; |
|
} |
|
|
|
private List<UserUser> getUserUsers() { |
|
List<UserUser> mUserUsers = new ArrayList<UserUser>(userUserCapacity); |
|
|
|
for (Iterator<HUserUser> userUserIter = hUserUserExtent.iterator(); userUserIter.hasNext();) { |
|
HUserUser hUserUser = userUserIter.next(); |
|
|
|
Query userPartQuery = moumiPM.newQuery(mUserPartExtent, "handyId == handy_id"); |
|
userPartQuery.declareParameters("String handy_id"); |
|
userPartQuery.setUnique(true); |
|
Query userUserQuery = moumiPM.newQuery(mUserUserExtent, "userPart == m_part && id == m_user"); |
|
userUserQuery.declareParameters("kr.co.kihyun.beans.entity.UserPart m_part, String m_user"); |
|
userUserQuery.setUnique(true); |
|
|
|
MUser mUser = null; |
|
try { |
|
mUser = moumiPM.getObjectById(MUser.class, hUserUser.getUserId()); |
|
} catch (javax.jdo.JDOObjectNotFoundException jnfe) { |
|
// LOG.warn("MUser@{} is not exists. so this user user will be ignored.", |
|
// hUserUser.getUserId()); |
|
continue; |
|
} |
|
UserPart mUserPart = (UserPart) userPartQuery.execute(hUserUser.getPartId()); |
|
if (mUserPart == null) { |
|
// LOG.warn("UserPart@{} is not exists. so this user user will be ignored.", |
|
// hUserUser.getPartId()); |
|
continue; |
|
} |
|
UserUser mUserUser = (UserUser) userUserQuery.execute(mUserPart, mUser.getId()); |
|
if (mUserUser == null) { |
|
mUserUser = new UserUser(mUser, hUserUser.getName(), mUser.getUpperDept(moumiPM), mUserPart); |
|
} |
|
|
|
mUserUser.setHandyId(hUserUser.getId()); |
|
mUserUser.setUser(mUser); |
|
mUserUser.setName(mUser.getName(moumiPM)); |
|
mUserUser.setDept(mUser.getUpperDept(moumiPM)); |
|
mUserUser.setPart(mUserPart); |
|
mUserUser.setValid(true); |
|
|
|
mUserUsers.add(mUserUser); |
|
} |
|
|
|
return mUserUsers; |
|
} |
|
|
|
private List<MDept> getDepts() { |
|
List<MDept> mDepts = new ArrayList<MDept>(deptCapacity); |
|
|
|
for (Iterator<HDept> deptIter = hDeptExtent.iterator(); deptIter.hasNext();) { |
|
HDept hDept = deptIter.next(); |
|
|
|
Query q = moumiPM.newQuery(mDeptExtent, "handyId == handy_id"); |
|
q.declareParameters("String handy_id"); |
|
q.setUnique(true); |
|
MDept mDept = (MDept) q.execute(hDept.getId()); |
|
|
|
if (mDept == null) { |
|
mDept = new MDept(hDept.getPasscode(), hDept.getName()); |
|
} |
|
|
|
// mDept.setName(hDept.getName()); |
|
// mDept.setPasscode(hDept.getPasscode()); |
|
// mDept.setHandyId(hDept.getId()); |
|
// mDept.setAddress(hDept.getAddress1() + hDept.getAddress2()); |
|
// mDept.setPriority(hDept.getPriority()); |
|
// mDept.setDocUnit(hDept.isDocUnit()); |
|
q = moumiPM.newQuery(mDeptExtent, "handyId == handy_id"); |
|
q.declareParameters("String handy_id"); |
|
q.setUnique(true); |
|
// mDept.setUpperDept((MDept) q.execute(hDept.getUpperDept())); |
|
|
|
mDepts.add(mDept); |
|
} |
|
|
|
return mDepts; |
|
} |
|
|
|
private List<MUser> getUsers() { |
|
List<MUser> mUsers = new ArrayList<MUser>(userCapacity); |
|
|
|
for (Iterator<HUser> deptIter = hUserExtent.iterator(); deptIter.hasNext();) { |
|
HUser hUser = deptIter.next(); |
|
MUser mUser = null; |
|
|
|
Query docUnitQuery = handyPM.newQuery(hReceiverExtent, "userId == currentUserId"); |
|
docUnitQuery.declareParameters("String currentUserId"); |
|
Query deptQuery = moumiPM.newQuery(mDeptExtent, "handyId == handy_id"); |
|
deptQuery.declareParameters("String handy_id"); |
|
deptQuery.setUnique(true); |
|
|
|
try { |
|
mUser = moumiPM.getObjectById(MUser.class, hUser.getId()); |
|
} catch (javax.jdo.JDOObjectNotFoundException jnfe) { |
|
mUser = new MUser(); |
|
// mUser.setId(hUser.getId()); |
|
} |
|
|
|
List<HDocUnit> receivers = (List<HDocUnit>) docUnitQuery.execute(hUser.getId()); |
|
Set<MDept> depts = new HashSet<MDept>(); |
|
|
|
MDept upperDept = null; |
|
if (receivers.size() == 0) { // if this user is not document manager |
|
upperDept = (MDept) deptQuery.execute(hUser.getmDept()); |
|
if (upperDept != null) |
|
depts.add(upperDept); |
|
} else { |
|
for (HDocUnit receiver : receivers) { // user can only have one dept. |
|
MDept tmpDept = (MDept) deptQuery.execute(receiver.getRelId()); |
|
if (tmpDept != null) { |
|
upperDept = tmpDept; |
|
depts.add(upperDept); |
|
} |
|
} |
|
// mUser.setRoles(Role.DOC_MANAGER); |
|
} |
|
|
|
if (upperDept == null) { |
|
// LOG.warn("upper dept for {} is not exists. so changing upper dept will be ignored.", |
|
// mUser); |
|
continue; |
|
} |
|
|
|
// mUser.setPassword(hUser.getPassword()); |
|
// mUser.setName(hUser.getName()); |
|
// mUser.setEmail(hUser.getEmail()); |
|
// mUser.setPhone(hUser.getPhone()); |
|
// mUser.setDeleted(hUser.isDeleted()); |
|
// mUser.setPriority(hUser.getPriority()); |
|
// mUser.setDutyName(hUser.getDutyName()); |
|
// mUser.setEmpCode(hUser.getEmpCode()); |
|
// mUser.setGwId(hUser.getEmpCode()); |
|
// mUser.setRoles(Role.DOC_MANAGER); |
|
// mUser.setDepts(depts); |
|
// mUser.setUpperDept(upperDept); |
|
|
|
mUsers.add(mUser); |
|
} |
|
|
|
return mUsers; |
|
} |
|
|
|
}
|
|
|