@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other == null || !(other instanceof PropertyDiffDisplay)) {
return false;
}
Serializable otherValue = ((PropertyDiffDisplay) other).getValue();
Serializable otherStyleClass = ((PropertyDiffDisplay) other).getStyleClass();
DifferenceType otherDifferenceType = ((PropertyDiffDisplay) other).getDifferenceType();
if (value == null
&& otherValue == null
&& styleClass == null
&& otherStyleClass == null
&& differenceType.equals(otherDifferenceType)) {
return true;
}
return differenceType.equals(otherDifferenceType)
&& (value == null
&& otherValue == null
&& styleClass != null
&& styleClass.equals(otherStyleClass)
|| styleClass == null
&& otherStyleClass == null
&& value != null
&& value.equals(otherValue)
|| value != null
&& value.equals(otherValue)
&& styleClass != null
&& styleClass.equals(otherStyleClass));
}
@Override
public Serializable getCurrentFromResultSet(
ResultSet rs, List<Column> columns, Model model, Serializable[] returnId, int[] returnPos)
throws SQLException {
Serializable id = null;
Serializable value = null;
int i = 0;
for (Column column : columns) {
i++;
String key = column.getKey();
Serializable v = column.getFromResultSet(rs, i);
if (key.equals(model.MAIN_KEY)) {
id = v;
} else if (key.equals(model.COLL_TABLE_POS_KEY)) {
// (the pos column is ignored, results are already ordered by id
// then pos)
} else if (key.equals(model.COLL_TABLE_VALUE_KEY)) {
value = v;
} else {
throw new RuntimeException(key);
}
}
Serializable prevId = returnId[0];
returnId[0] = id;
int pos = (id != null && !id.equals(prevId)) ? 0 : returnPos[0] + 1;
returnPos[0] = pos;
return value;
}
public void testUidGeneration() {
Serializable id = this.uidGenerator.generateUid();
assertNotNull(id);
Serializable id2 = this.uidGenerator.generateUid();
assertNotNull(id2);
assertFalse(id.equals(id2));
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof SerializableData)) {
return false;
}
final SerializableData other = (SerializableData) obj;
return (raw == null ? other.raw == null : raw.equals(other.raw))
&& Arrays.equals(serialized, other.serialized);
}
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final InstanceImpl instance = (InstanceImpl) o;
if (Double.compare(instance.weight, weight) != 0) return false;
if (!attributes.equals(instance.attributes)) return false;
if (!label.equals(instance.label)) return false;
return true;
}
/**
* 记录一条日志【登陆，逻辑，异常】
*
* @param logText
* @param classStr
* @param exceptions
* @author 朱启亮
* @date 2008-1-31
*/
public void saveLog(JoinPoint jp, String logText, String classStr, Exception... exceptions) {
Object obj = jp.getThis();
String ip = "unknow";
if (obj instanceof AbstractAction) {
AbstractAction action = (AbstractAction) obj;
HttpServletRequest request = action.getRequest();
ip = this.getIpAddr(request);
}
HttpSession session = (HttpSession) UserSession.get(Constants.THREADLOCAL_CURRENT_SESSION);
Serializable personid = (Serializable) session.getAttribute(Constants.SESSION_CURRENT_PERSONID);
Person person = null;
// 区分游客，root用户，普通用户
if (personid == null) {
person = new Person();
person.setUserName(Constants.GUEST_NAME);
person.setId(Constants.GUEST_ID);
person.setUserLoginName(Constants.GUEST_NAME);
} else if (personid.equals(Constants.ADMINISTRATOR_ID)) {
person = new Person();
person.setUserName(Constants.ADMINISTRATOR_NAME);
person.setId(Constants.ADMINISTRATOR_ID);
person.setUserLoginName(Constants.ADMINISTRATOR_ACCOUNT);
} else {
PersonManager personManager = this.getPersonManager();
person = personManager.get(personid);
}
StringUtil.isoToUTF8(logText);
Log log = new Log();
log.setIp(ip);
log.setLog(logText);
log.setDt(new Date());
// 记录日志的类型
if (exceptions.length == 0) {
// if(classStr.equals(Constants.LOGINACTION)){
// log.setType(Log.LOG_TYPE_LOGIN);
// }else{
log.setType(Log.LOG_TYPE_LOGIC);
// }
} else {
log.setType(Log.LOG_TYPE_EXCEPTION);
}
log.setPersonName(person.getUserName());
if (person.getUserName().equals(Constants.GUEST_NAME)
|| person.getUserName().equals(Constants.ADMINISTRATOR_NAME)) {
log.setPersonLoginName(person.getUserLoginName());
} else {
log.setPersonLoginName(person.getUserLoginName());
}
logManager.save(log);
}
private void evictCache(
Object entity, EntityPersister persister, EventSource session, Object[] oldState) {
try {
SessionFactoryImplementor factory = persister.getFactory();
Set<String> collectionRoles =
factory.getCollectionRolesByEntityParticipant(persister.getEntityName());
if (collectionRoles == null || collectionRoles.isEmpty()) {
return;
}
for (String role : collectionRoles) {
CollectionPersister collectionPersister = factory.getCollectionPersister(role);
if (!collectionPersister.hasCache()) {
// ignore collection if no caching is used
continue;
}
// this is the property this OneToMany relation is mapped by
String mappedBy = collectionPersister.getMappedByProperty();
if (mappedBy != null) {
int i = persister.getEntityMetamodel().getPropertyIndex(mappedBy);
Serializable oldId = null;
if (oldState != null) {
// in case of updating an entity we perhaps have to decache 2 entity collections, this
// is the
// old one
oldId = session.getIdentifier(oldState[i]);
}
Object ref = persister.getPropertyValue(entity, i);
Serializable id = null;
if (ref != null) {
id = session.getIdentifier(ref);
}
// only evict if the related entity has changed
if (id != null && !id.equals(oldId)) {
evict(id, collectionPersister, session);
if (oldId != null) {
evict(oldId, collectionPersister, session);
}
}
} else {
LOG.debug("Evict CollectionRegion " + role);
collectionPersister.getCacheAccessStrategy().evictAll();
}
}
} catch (Exception e) {
// don't let decaching influence other logic
LOG.error("", e);
}
}
/**
* The second stage of the <code>NodeRef</code> repointing. Call this method to have any <code>
* NodeRef</code> properties readjusted to reflect the copied node hierarchy. Only use this method
* if it a requirement for the particular type or aspect that you are coding for.
*
* @param sourceNodeRef the source node
* @param propertyQName the target node i.e. the copy of the source node
* @param copyMap the full hierarchy copy map of source to copies
* @see #recordNodeRefsForRepointing(NodeRef, Map, QName)
*/
@SuppressWarnings("unchecked")
public void repointNodeRefs(
NodeRef sourceNodeRef,
NodeRef targetNodeRef,
QName propertyQName,
Map<NodeRef, NodeRef> copyMap,
NodeService nodeService) {
String key = KEY_NODEREF_REPOINTING_PREFIX + propertyQName.toString();
Map<NodeRef, Serializable> map = TransactionalResourceHelper.getMap(key);
Serializable value = map.get(sourceNodeRef);
if (value == null) {
// Don't bother. The source node did not have a NodeRef property
return;
}
Serializable newValue = null;
if (value instanceof Collection) {
Collection<Serializable> oldList = (Collection<Serializable>) value;
List<Serializable> newList = new ArrayList<Serializable>(oldList.size());
for (Serializable oldListValue : oldList) {
Serializable newListValue = oldListValue;
if (oldListValue instanceof NodeRef) {
newListValue = repointNodeRef(copyMap, (NodeRef) oldListValue);
}
// Put the value in the new list even though the new list might be discarded
newList.add(newListValue);
// Check if the value changed
if (!newListValue.equals(oldListValue)) {
// The value changed, so the new list will have to be set onto the target node
newValue = (Serializable) newList;
}
}
} else if (value instanceof NodeRef) {
NodeRef newNodeRef = repointNodeRef(copyMap, (NodeRef) value);
if (!newNodeRef.equals(value)) {
// The value changed, so the new list will have to be set onto the target node
newValue = newNodeRef;
}
} else {
throw new IllegalStateException("Should only have Collections and NodeRef values");
}
// Fix the node property on the target, if necessary
if (newValue != null) {
nodeService.setProperty(targetNodeRef, propertyQName, newValue);
}
}
protected void registerEntityMapping(
final Class<?> entityClass, final Serializable oldId, final Serializable newId) {
final Serializable registeredNewId = getNewId(entityClass, oldId);
if (registeredNewId != null && registeredNewId.equals(newId) == false) {
log.error(
"Oups, double entity mapping found for entity '"
+ entityClass
+ "' with old id="
+ oldId
+ " . New id "
+ newId
+ " ignored, using previous stored id "
+ registeredNewId
+ " instead.");
} else {
this.entityMapping.put(getClassname4History(entityClass) + oldId, newId);
}
}
@Test
public void testKeyUniqueObject() throws Exception {
OnHeapStore<Serializable, Serializable> store = newStore();
List<String> key = new ArrayList<String>();
key.add("key");
String value = "value";
store.put((Serializable) key, value);
// mutate the key -- should not affect cache
key.clear();
Serializable storeKey = store.iterator().next().getKey();
if (storeKey == key || !storeKey.equals(Collections.singletonList("key"))) {
throw new AssertionError();
}
}
/**
* Returns {@code true} if the specified argument is an {@code instanceof} {@code SimpleSession}
* and both {@link #getId() id}s are equal. If the argument is a {@code SimpleSession} and either
* 'this' or the argument does not yet have an ID assigned, the value of {@link
* #onEquals(SimpleSession) onEquals} is returned, which does a necessary attribute-based
* comparison when IDs are not available.
*
* <p>Do your best to ensure {@code SimpleSession} instances receive an ID very early in their
* lifecycle to avoid the more expensive attributes-based comparison.
*
* @param obj the object to compare with this one for equality.
* @return {@code true} if this object is equivalent to the specified argument, {@code false}
* otherwise.
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof SimpleSession) {
SimpleSession other = (SimpleSession) obj;
Serializable thisId = getId();
Serializable otherId = other.getId();
if (thisId != null && otherId != null) {
return thisId.equals(otherId);
} else {
// fall back to an attribute based comparison:
return onEquals(other);
}
}
return false;
}
/**
* Test that validates functionality for issue <a
* href="https://issues.apache.org/jira/browse/JSEC-22">JSEC-22</a>
*/
@Test
public void testSubjectReuseAfterLogout() {
Subject subject = SecurityUtils.getSubject();
AuthenticationToken token = new UsernamePasswordToken("guest", "guest");
subject.login(token);
assertTrue(subject.isAuthenticated());
assertTrue("guest".equals(subject.getPrincipal()));
assertTrue(subject.hasRole("guest"));
Session session = subject.getSession();
Serializable firstSessionId = session.getId();
session.setAttribute("key", "value");
assertEquals(session.getAttribute("key"), "value");
subject.logout();
assertNull(subject.getSession(false));
assertNull(subject.getPrincipal());
assertNull(subject.getPrincipals());
subject.login(new UsernamePasswordToken("lonestarr", "vespa"));
assertTrue(subject.isAuthenticated());
assertTrue("lonestarr".equals(subject.getPrincipal()));
assertTrue(subject.hasRole("goodguy"));
assertNotNull(subject.getSession());
assertFalse(firstSessionId.equals(subject.getSession().getId()));
subject.logout();
assertNull(subject.getSession(false));
assertNull(subject.getPrincipal());
assertNull(subject.getPrincipals());
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof DataMap)) {
return false;
}
DataMap other = (DataMap) obj;
if (isEmpty() && other.isEmpty()) {
return true;
}
for (Map.Entry<? extends String, ? extends Serializable> e : entrySet()) {
Serializable value = e.getValue();
Serializable otherValue = other.get(e.getKey());
if (value != null) {
if (!value.equals(otherValue)) {
return false;
}
} else if (otherValue != null) {
return false;
}
}
return true;
}
/**
* @param test_name Name used to refer to the serialized instance. If a test output dir is
* specified (see constructor), a file will be created with this name.
*/
private boolean serializesCorrectly(Serializable obj, String test_name) {
assert obj instanceof Externalizable : obj + " is not Externalizable";
ObjectOutputStream oout = null;
ObjectInputStream oin = null;
try {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
oout = new ObjectOutputStream(bout);
oout.writeObject(obj);
oout.close();
ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
oin = new ObjectInputStream(bin);
Object new_obj = oin.readObject();
if (!obj.equals(new_obj)) {
System.err.println("Non-matching serialized objects (in-VM test):");
System.err.println(" Original: " + obj);
System.err.println(" Deserialized: " + new_obj);
return false;
}
if (obj instanceof THash) {
assertEquals(
((THash) obj).getAutoCompactionFactor(),
((THash) new_obj).getAutoCompactionFactor(),
0.0);
}
oin.close();
if (serialized_object_output_dir != null) {
try {
File file = new File(serialized_object_output_dir, test_name + ".obj");
ObjectOutputStream test_out = new ObjectOutputStream(new FileOutputStream(file));
test_out.writeObject(obj);
test_out.close();
} catch (IOException ex) {
ex.printStackTrace();
fail("Unable to write to test file: " + test_name);
}
}
// Look for previous versions
int version = 0;
for (; ; version++) {
InputStream stream =
SerializationTest.class.getResourceAsStream(
"old_serialized_versions/" + version + "/" + test_name + ".obj");
if (stream == null) break;
System.out.println("Testing " + test_name + " against version " + version + "...");
oin = new ObjectInputStream(stream);
new_obj = oin.readObject();
if (!obj.equals(new_obj)) {
System.err.println("Non-matching serialized objects (version " + version + "):");
System.err.println(" Original: " + obj);
System.err.println(" Deserialized: " + new_obj);
return false;
}
}
return true;
} catch (Exception ex) {
ex.printStackTrace();
return false;
} finally {
if (oout != null) {
try {
oout.close();
} catch (IOException ex) {
// ignore
}
}
if (oin != null) {
try {
oin.close();
} catch (IOException ex) {
// ignore
}
}
}
}
/** @param args */
public static void main(final String[] args) throws Exception {
final BufferedReader br =
new BufferedReader(
new InputStreamReader(
(new GZIPInputStream(
new FileInputStream(
new File(
new File(System.getProperty("user.dir")), "testdata/mobo1.txt.gz"))))));
final List<Instance> instances = Lists.newLinkedList();
int count = 0;
while (true) {
count++;
final String line = br.readLine();
if (line == null) {
break;
}
final JSONObject jo = (JSONObject) JSONValue.parse(line);
final HashMapAttributes a = new HashMapAttributes();
a.putAll((JSONObject) jo.get("attributes"));
Instance instance = new Instance(a, (String) jo.get("output"));
instances.add(instance);
}
final List<Instance> train = instances.subList(0, instances.size() / 2);
final List<Instance> test = instances.subList(instances.size() / 2 + 1, instances.size() - 1);
System.out.println("Read " + instances.size() + " instances");
System.out.println("Testing scorers with single decision node");
for (final Scorer scorer : Sets.newHashSet(new Scorer1())) {
final TreeBuilder tb = new TreeBuilder(scorer);
final long startTime = System.currentTimeMillis();
final Node tree = tb.buildPredictiveModel(train).node;
System.out.println(
scorer.getClass().getSimpleName()
+ " build time "
+ (System.currentTimeMillis() - startTime)
+ ", size: "
+ tree.size()
+ " mean depth: "
+ tree.meanDepth());
int correctlyClassified = 0;
for (Instance testInstance : test) {
String result = (String) tree.getLeaf(testInstance.getAttributes()).getBestClassification();
if (result.equals(testInstance.getClassification())) {
correctlyClassified++;
}
}
System.out.println(", accuracy: " + (double) correctlyClassified / test.size());
System.out.println("Testing random forest");
for (int i = 2; i <= 20; i++) {
RandomForestBuilder rfBuilder = new RandomForestBuilder(new TreeBuilder());
RandomForest randomForest = rfBuilder.buildPredictiveModel(train);
correctlyClassified = 0;
for (Instance testInstance : test) {
Serializable result =
randomForest.getClassificationByMaxProb(testInstance.getAttributes());
if (result.equals(testInstance.getClassification())) {
correctlyClassified++;
}
}
System.out.println(
"accuracy with " + i + " trees: " + (double) correctlyClassified / test.size());
// ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new
// File("baggedTree.ser")));
// out.writeObject(baggedTree);
}
}
}
@Override
protected Condition getGridSpecalCondition() {
OrCondition orCondition = new OrCondition();
AndCondition operateFoldersCondition = new AndCondition();
AndCondition publicFoldersCondition = new AndCondition();
// 状态条件
Condition statusCondition = null;
Condition typeCondition = null;
// Condition userCondition = null;
Condition authorityCondition = null;
Condition eliminateCondition = null;
// Condition tierCondition = null;
// 状态
if (status != null && status.length() > 0) {
String[] ss = status.split(",");
if (ss.length == 1) {
statusCondition = new EqualsCondition("f.status_", new Integer(ss[0]));
} else {
statusCondition = new InCondition("f.status_", StringUtils.stringArray2IntegerArray(ss));
}
}
// 文件夹类型
typeCondition = new EqualsCondition("f.type_", NetdiskFile.TYPE_FOLDER);
// 当前用户只能查看自己上传的文件
SystemContext context = (SystemContext) this.getContext();
// userCondition = new EqualsCondition("f.author_id", context
// .getUserHistory().getId());
// 文件夹不能隶属于自己
if (folderId != null) {
eliminateCondition = new NotEqualsCondition("f.id", folderId);
}
// 父级文件夹不能隶属子级
// 当前用户有权限查看的文件
Serializable[] ids = this.netdiskFileService.getUserSharFileId2All(context.getUser().getId());
// 查找当前文件的父级
// 可以操作的文件夹id
List<Object> operateId = new ArrayList<Object>();
if (folderId != null) {
Serializable[] myselfAndChildId = this.netdiskFileService.getMyselfAndChildFileId(folderId);
// 排除自己与子文件id后来的数组
List<Object> eliminateId = new ArrayList<Object>();
if (ids != null) {
for (Serializable id : ids) {
boolean isIn = false;
for (Serializable pid : myselfAndChildId) {
if (id.equals(pid)) {
isIn = true;
break;
}
}
if (!isIn) {
eliminateId.add(id);
}
}
// 找出可操作的id
if (!eliminateId.isEmpty()) {
for (int i = 0; i < eliminateId.size(); i++) {
// 查看当前文件是否设置访问权限，如果有就根据当前的权限来判断
NetdiskShare myNetdiskShare =
this.netdiskFileService.getNetdiskShare(
context.getUser().getId(), Long.valueOf(eliminateId.get(i).toString()));
// 如果是自己的建的文件夹也操作
NetdiskFile netdiskFile =
this.netdiskFileService.load(Long.valueOf(eliminateId.get(i).toString()));
if (netdiskFile.getAuthor().getId().equals(context.getUserHistory().getId())) {
operateId.add(eliminateId.get(i));
} else if (myNetdiskShare != null) {
if (haveAuthority(myNetdiskShare.getRole(), 0)) {
// 如果有权限就添加
operateId.add(eliminateId.get(i));
}
} else {
// 获取当前的文件和父级文件
Serializable[] ParentIds =
this.netdiskFileService.getMyselfAndParentsFileId(
Long.valueOf(eliminateId.get(i).toString()));
// 判断当前文件或父级文件夹该用户是否拥有编辑权限
for (Serializable pid : ParentIds) {
boolean isOwer = false;
NetdiskFile nf = this.netdiskFileService.load(pid);
Set<NetdiskShare> netdiskShare = nf.getFileVisitors();
if (!netdiskShare.isEmpty()) {
Iterator<NetdiskShare> n = netdiskShare.iterator();
while (n.hasNext()) {
NetdiskShare ns = n.next();
if (ns.getAid().equals(context.getUser().getId())) {
if (haveAuthority(ns.getRole(), 0)) {
// 如果有权限就添加
operateId.add(eliminateId.get(i));
isOwer = true;
break;
}
}
}
if (isOwer) {
break;
}
}
}
}
}
}
}
// 组装条件
String qlStr4File = "";
if (operateId.size() != 0) {
for (int i = 0; i < operateId.size(); i++) {
if (i + 1 != operateId.size()) {
qlStr4File += "?,";
} else {
qlStr4File += "?";
}
}
}
authorityCondition =
orCondition
.add(
(operateId.size() != 0
? new QlCondition("f.id in (" + qlStr4File + ")", operateId)
: null))
.setAddBracket(true);
}
// 如果是公共硬盘管理员可以选择公共硬盘的文件夹
Condition publicCondition = null;
if (this.isPublicHardDiskManagement()) {
publicCondition = new EqualsCondition("f.folder_type", NetdiskFile.FOLDER_TYPE_PUBLIC);
}
// 可以操作的文件夹不为空和有权限的
if (operateId.size() != 0 && publicCondition != null) {
return ConditionUtils.mix2OrCondition(
operateFoldersCondition
.add(statusCondition, typeCondition, eliminateCondition, authorityCondition)
.setAddBracket(true),
publicFoldersCondition
.add(statusCondition, publicCondition, typeCondition)
.setAddBracket(true));
// 没有公共硬盘管理权限的
} else if (operateId.size() != 0 && publicCondition == null) {
return operateFoldersCondition.add(
statusCondition, typeCondition, eliminateCondition, authorityCondition);
// 没有可以操作的文件但有公共权限的
} else if (operateId.size() == 0 && publicCondition != null) {
return publicFoldersCondition.add(statusCondition, publicCondition, typeCondition);
} else {
return null;
}
}
/**
* Returns a session object. First, a key is generated by the session manager's key provider,
* based on the JRadiusRequest. If there is a stored session based on the key, this session is
* returned, otherwise a new session created by the session factory is returned
*
* @param request a JRadiusRequest used to retrieve or generate a session with
* @return Returns a RadiusSession
* @throws RadiusException
*/
public JRadiusSession getSession(JRadiusRequest request) throws RadiusException {
SessionKeyProvider skp = getSessionKeyProvider(request.getSender());
Serializable key = skp.getAppSessionKey(request);
JRadiusSession session = null;
Serializable nkey = null;
if (key != null) {
RadiusLog.debug("** Looking for session: " + key);
session = getSession(request, key);
if (session == null) {
RadiusLog.error("Broken JRadius-Session-Id implementation for session: " + key);
key = null;
}
}
if (key == null) {
key = skp.getClassKey(request);
if (key != null) {
RadiusLog.debug("** Looking for session: " + key);
session = getSession(request, key);
if (session == null) {
RadiusLog.error("Broken Class implementation for session: " + key);
key = null;
} else {
if (session.getJRadiusKey() != null
&& !session.getJRadiusKey().equals(session.getSessionKey())) {
rehashSession(session, session.getJRadiusKey(), key);
}
}
}
}
if (key == null) {
Serializable keys = skp.getRequestSessionKey(request);
if (keys == null) {
return null;
}
if (keys instanceof Serializable[]) {
key = ((Serializable[]) (keys))[0];
nkey = ((Serializable[]) (keys))[1];
RadiusLog.debug("Rehashing session with key " + key + " under new key " + nkey);
} else {
key = keys;
}
RadiusLog.debug("** Looking for session: " + key);
session = getSession(request, key);
if (session != null && nkey != null && !nkey.equals(key)) {
rehashSession(session, key, nkey);
}
}
if (session == null) {
session = newSession(request, nkey == null ? key : nkey);
} else {
session.setNewSession(false);
}
session.setTimeStamp(System.currentTimeMillis());
session.setLastRadiusRequest(request);
return session;
}
protected List<Serializable> getFieldValues(
DDMStructure ddmStructure,
String fieldName,
String fieldNamespace,
ServiceContext serviceContext)
throws PortalException {
DDMFormField ddmFormField = ddmStructure.getDDMFormField(fieldName);
String fieldDataType = ddmFormField.getDataType();
String fieldType = ddmFormField.getType();
LocalizedValue predefinedValue = ddmFormField.getPredefinedValue();
List<String> fieldNames = getFieldNames(fieldNamespace, fieldName, serviceContext);
List<Serializable> fieldValues = new ArrayList<>(fieldNames.size());
for (String fieldNameValue : fieldNames) {
Serializable fieldValue = serviceContext.getAttribute(fieldNameValue);
if (Validator.isNull(fieldValue)) {
fieldValue = predefinedValue.getString(serviceContext.getLocale());
}
if (fieldType.equals(DDMImpl.TYPE_CHECKBOX) && Validator.isNull(fieldValue)) {
fieldValue = "false";
} else if (fieldDataType.equals(FieldConstants.DATE)) {
Date fieldValueDate = null;
if (Validator.isNull(fieldValue)) {
int fieldValueMonth =
GetterUtil.getInteger(serviceContext.getAttribute(fieldNameValue + "Month"));
int fieldValueDay =
GetterUtil.getInteger(serviceContext.getAttribute(fieldNameValue + "Day"));
int fieldValueYear =
GetterUtil.getInteger(serviceContext.getAttribute(fieldNameValue + "Year"));
fieldValueDate = PortalUtil.getDate(fieldValueMonth, fieldValueDay, fieldValueYear);
} else {
try {
fieldValueDate =
DateUtil.parseDate(String.valueOf(fieldValue), serviceContext.getLocale());
} catch (ParseException pe) {
if (_log.isErrorEnabled()) {
_log.error("Unable to parse date " + fieldValue);
}
}
}
if (fieldValueDate != null) {
fieldValue = String.valueOf(fieldValueDate.getTime());
}
} else if (fieldDataType.equals(FieldConstants.IMAGE) && Validator.isNull(fieldValue)) {
HttpServletRequest request = serviceContext.getRequest();
if (request instanceof UploadRequest) {
String imageFieldValue = getImageFieldValue((UploadRequest) request, fieldNameValue);
if (Validator.isNotNull(imageFieldValue)) {
fieldValue = imageFieldValue;
}
}
}
if (Validator.isNull(fieldValue)) {
return null;
}
if (DDMImpl.TYPE_RADIO.equals(fieldType) || DDMImpl.TYPE_SELECT.equals(fieldType)) {
String predefinedValueString = predefinedValue.getString(serviceContext.getLocale());
if (!fieldValue.equals(predefinedValueString) && (fieldValue instanceof String)) {
fieldValue = new String[] {String.valueOf(fieldValue)};
fieldValue = JSONFactoryUtil.serialize(fieldValue);
}
}
Serializable fieldValueSerializable =
FieldConstants.getSerializable(fieldDataType, GetterUtil.getString(fieldValue));
fieldValues.add(fieldValueSerializable);
}
return fieldValues;
}