/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*******************************************************************************/
package org.apache.ofbiz.common.preferences;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GeneralException;
import org.apache.ofbiz.base.util.ObjectType;
import static org.apache.ofbiz.base.util.UtilGenerics.checkMap;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.ServiceUtil;
/**
* User preference services.<p>User preferences are stored as key-value pairs.
* <p>User preferences can be grouped - so that multiple preference pairs can be
* handled at once. Preference groups also allow a single userPrefTypeId to be
* used more than once - with each occurence having a unique userPrefGroupTypeId.</p>
* <p>User preference values are stored as Strings, so the easiest and most
* efficient way to handle user preference values is to keep them as strings.
* This class handles any data conversion needed.</p>
*/
public class PreferenceServices {
public static final String module = PreferenceServices.class.getName();
public static final String resource = "PrefErrorUiLabels";
/**
* Retrieves a single user preference from persistent storage. Call with
* userPrefTypeId and optional userPrefLoginId. If userPrefLoginId isn't
* specified, then the currently logged-in user's userLoginId will be
* used. The retrieved preference is contained in the <b>userPrefMap</b> element.
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreference(DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefTypeId = (String) context.get("userPrefTypeId");
if (UtilValidate.isEmpty(userPrefTypeId)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, true);
Map<String, String> fieldMap = UtilMisc.toMap("userLoginId", userLoginId, "userPrefTypeId", userPrefTypeId);
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isNotEmpty(userPrefGroupTypeId)) {
fieldMap.put("userPrefGroupTypeId", userPrefGroupTypeId);
}
Map<String, Object> userPrefMap = null;
try {
GenericValue preference = EntityQuery.use(delegator).from("UserPreference").where(fieldMap).cache(true).queryFirst();
if (preference != null) {
userPrefMap = PreferenceWorker.createUserPrefMap(preference);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.readFailure", new Object[] { e.getMessage() }, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.readFailure", new Object[] { e.getMessage() }, locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
if (userPrefMap != null) {
// Put the value in the result Map too, makes access easier for calling methods.
Object userPrefValue = userPrefMap.get(userPrefTypeId);
if (userPrefValue != null) {
result.put("userPrefValue", userPrefValue);
}
}
return result;
}
/**
* Retrieves a group of user preferences from persistent storage. Call with
* userPrefGroupTypeId and optional userPrefLoginId. If userPrefLoginId isn't
* specified, then the currently logged-in user's userLoginId will be
* used. The retrieved preferences group is contained in the <b>userPrefMap</b> element.
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreferenceGroup(DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userPrefGroupTypeId)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
Map<String, Object> userPrefMap = null;
try {
Map<String, String> fieldMap = UtilMisc.toMap("userLoginId", "_NA_", "userPrefGroupTypeId", userPrefGroupTypeId);
userPrefMap = PreferenceWorker.createUserPrefMap(EntityQuery.use(delegator).from("UserPreference").where(fieldMap).cache(true).queryList());
if (userLoginId != null) {
fieldMap.put("userLoginId", userLoginId);
userPrefMap.putAll(PreferenceWorker.createUserPrefMap(EntityQuery.use(delegator).from("UserPreference").where(fieldMap).cache(true).queryList()));
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.readFailure", new Object[] { e.getMessage() }, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "getPreference.readFailure", new Object[] { e.getMessage() }, locale));
}
// for the 'DEFAULT' values find the related values in general properties and if found use those.
Properties generalProperties = UtilProperties.getProperties("general");
for (Map.Entry<String, Object> pairs: userPrefMap.entrySet()) {
if ("DEFAULT".equals(pairs.getValue())) {
if (UtilValidate.isNotEmpty(generalProperties.get(pairs.getKey()))) {
userPrefMap.put(pairs.getKey(), generalProperties.get(pairs.getKey()));
}
}
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
return result;
}
/**
* Stores a single user preference in persistent storage. Call with
* userPrefTypeId, userPrefGroupTypeId, userPrefValue and optional userPrefLoginId.
* If userPrefLoginId isn't specified, then the currently logged-in user's
* userLoginId will be used.
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> setUserPreference(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String userPrefTypeId = (String) context.get("userPrefTypeId");
Object userPrefValue = context.get("userPrefValue");
if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefTypeId) || userPrefValue == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale));
}
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
String userPrefDataType = (String) context.get("userPrefDataType");
try {
if (UtilValidate.isNotEmpty(userPrefDataType)) {
userPrefValue = ObjectType.simpleTypeConvert(userPrefValue, userPrefDataType, null, null, false);
}
GenericValue rec = delegator.makeValidValue("UserPreference", PreferenceWorker.toFieldMap(userLoginId, userPrefTypeId, userPrefGroupTypeId, userPrefValue));
delegator.createOrStore(rec);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.writeFailure", new Object[] { e.getMessage() }, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.writeFailure", new Object[] { e.getMessage() }, locale));
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> removeUserPreference(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String userPrefTypeId = (String) context.get("userPrefTypeId");
if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefTypeId)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale));
}
try {
GenericValue rec = EntityQuery.use(delegator)
.from("UserPreference")
.where("userLoginId", userLoginId, "userPrefTypeId", userPrefTypeId)
.queryOne();
if (rec != null) {
rec.remove();
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.writeFailure", new Object[] { e.getMessage() }, locale));
}
return ServiceUtil.returnSuccess();
}
/**
* Stores a user preference group in persistent storage. Call with
* userPrefMap, userPrefGroupTypeId and optional userPrefLoginId. If userPrefLoginId
* isn't specified, then the currently logged-in user's userLoginId will be
* used.
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> setUserPreferenceGroup(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
Map<String, Object> userPrefMap = checkMap(context.get("userPrefMap"), String.class, Object.class);
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefGroupTypeId) || userPrefMap == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale));
}
try {
for (Map.Entry<String, Object> mapEntry: userPrefMap.entrySet()) {
GenericValue rec = delegator.makeValidValue("UserPreference", PreferenceWorker.toFieldMap(userLoginId, mapEntry.getKey(), userPrefGroupTypeId, mapEntry.getValue()));
delegator.createOrStore(rec);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.writeFailure", new Object[] { e.getMessage() }, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "setPreference.writeFailure", new Object[] { e.getMessage() }, locale));
}
return ServiceUtil.returnSuccess();
}
/**
* Copies a user preference group. Call with
* fromUserLoginId, userPrefGroupTypeId and optional userPrefLoginId. If userPrefLoginId
* isn't specified, then the currently logged-in user's userLoginId will be
* used.
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> copyUserPreferenceGroup(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String fromUserLoginId = (String) context.get("fromUserLoginId");
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefGroupTypeId) || UtilValidate.isEmpty(fromUserLoginId)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "copyPreference.invalidArgument", locale));
}
try {
List<GenericValue> resultList = EntityQuery.use(delegator)
.from("UserPreference")
.where("userLoginId", fromUserLoginId, "userPrefGroupTypeId", userPrefGroupTypeId)
.queryList();
if (resultList != null) {
for (GenericValue preference: resultList) {
preference.set("userLoginId", userLoginId);
}
delegator.storeAll(resultList);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "copyPreference.writeFailure", new Object[] { e.getMessage() }, locale));
}
return ServiceUtil.returnSuccess();
}
}