606 lines
22 KiB
Java
606 lines
22 KiB
Java
package org.gcube.portlets.admin.authportletmanager.server;
|
|
|
|
import static org.gcube.common.authorization.client.Constants.authorizationService;
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import javax.servlet.ServletException;
|
|
import javax.servlet.http.HttpSession;
|
|
|
|
import org.gcube.application.framework.core.session.ASLSession;
|
|
import org.gcube.common.authorization.library.policies.Action;
|
|
import org.gcube.common.authorization.library.policies.Policy;
|
|
import org.gcube.common.authorization.library.policies.PolicyType;
|
|
import org.gcube.common.authorization.library.policies.Roles;
|
|
import org.gcube.common.authorization.library.policies.Service2ServicePolicy;
|
|
import org.gcube.common.authorization.library.policies.ServiceAccess;
|
|
import org.gcube.common.authorization.library.policies.Services;
|
|
import org.gcube.common.authorization.library.policies.User2ServicePolicy;
|
|
import org.gcube.common.authorization.library.policies.Users;
|
|
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
|
|
import org.gcube.common.resources.gcore.GCoreEndpoint;
|
|
import org.gcube.portlets.admin.authportletmanager.client.rpc.AuthManagerService;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.Access;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.Caller;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.Caller.TypeCaller;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.ConstantsSharing;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.PolicyAuth;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.Quote;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.Service;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.exceptions.ServiceException;
|
|
import org.gcube.portlets.admin.authportletmanager.shared.exceptions.TypeCallerException;
|
|
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
|
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
|
import org.gcube.vomanagement.usermanagement.GroupManager;
|
|
import org.gcube.vomanagement.usermanagement.RoleManager;
|
|
import org.gcube.vomanagement.usermanagement.UserManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayGroupManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayRoleManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayUserManager;
|
|
import org.gcube.vomanagement.usermanagement.model.GCubeRole;
|
|
import org.gcube.vomanagement.usermanagement.model.GCubeUser;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
|
|
|
|
/**
|
|
* AuthServiceImpl
|
|
*
|
|
* Support service request
|
|
*
|
|
* @author "Alessandro Pieve " <a
|
|
* href="mailto:alessandro.pieve@isti.cnr.it">alessandro.pieve@isti.cnr.it</a>
|
|
*
|
|
*/
|
|
@SuppressWarnings({ "serial", "deprecation" })
|
|
public class AuthServiceImpl extends RemoteServiceServlet
|
|
implements AuthManagerService {
|
|
|
|
private static Logger logger = LoggerFactory
|
|
.getLogger(AuthServiceImpl.class);
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
public void init() throws ServletException {
|
|
super.init();
|
|
System.out.println("Fix JAXP: jdk.xml.entityExpansionLimit=0");
|
|
System.setProperty("jdk.xml.entityExpansionLimit", "0");
|
|
|
|
System.out.println("initializing AccountingManager");
|
|
|
|
}
|
|
|
|
/**
|
|
* Load all list policy
|
|
*/
|
|
@Override
|
|
public ArrayList<PolicyAuth> loadListPolicy() throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ArrayList<PolicyAuth> policyList =new ArrayList<PolicyAuth>();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
String scope=aslSession.getScope();
|
|
String token =aslSession.getSecurityToken();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
token=ConstantsSharing.DEBUG_TOKEN;
|
|
scope="/gcube/devNext";
|
|
logger.debug("load list policy in scope:"+scope);
|
|
}
|
|
SecurityTokenProvider.instance.set(token);
|
|
List<Policy> policies = authorizationService().getPolicies(scope);
|
|
if (policies!=null){
|
|
logger.info("Load List Policy Find:"+policies.size());
|
|
if (policies.size()>0){
|
|
for (Policy policy : policies){
|
|
logger.debug("retrieve a policy service object"+policy);
|
|
ArrayList<Caller> callers =new ArrayList<Caller>();
|
|
boolean excludeCallers=false;
|
|
if (policy.getPolicyType()==PolicyType.USER){
|
|
//retrive caller type user or role
|
|
List<String> callerExcludes=((User2ServicePolicy) policy).getEntity().getExcludes();
|
|
TypeCaller typecaller=TypeCaller.valueOf(((User2ServicePolicy) policy).getEntity().getType().toString().toLowerCase());
|
|
logger.debug("callerExcludes:"+callerExcludes +" and size:"+callerExcludes.size());
|
|
if (callerExcludes.size()>0){
|
|
//condition with all excepiton
|
|
for (String callerExclude: callerExcludes){
|
|
callers.add(new Caller(typecaller,callerExclude));
|
|
}
|
|
excludeCallers=true;
|
|
}
|
|
else{
|
|
String callerIdentifier=((User2ServicePolicy) policy).getEntity().getIdentifier();
|
|
|
|
if (callerIdentifier==null)
|
|
callerIdentifier=ConstantsSharing.Star;
|
|
callers.add(new Caller(typecaller,callerIdentifier));
|
|
}
|
|
}
|
|
else{
|
|
//retrive caller type service
|
|
logger.debug("retrieve a policy service"+policy.toString());
|
|
String callerIdentifier=((Service2ServicePolicy) policy).getClient().getService().getName().toString()+
|
|
":"+((Service2ServicePolicy) policy).getClient().getService().getServiceClass()+
|
|
":"+((Service2ServicePolicy) policy).getClient().getService().getServiceId().toString();
|
|
TypeCaller typecaller=TypeCaller.valueOf("service");
|
|
callers.add(new Caller(typecaller,callerIdentifier));
|
|
}
|
|
Long idpolicy=policy.getId();
|
|
String serviceClass="ALL";
|
|
String serviceName="ALL";
|
|
String serviceId="ALL";
|
|
if (!policy.getServiceAccess().toString().equals("*")){
|
|
serviceClass=policy.getServiceAccess().getServiceClass();
|
|
serviceName=policy.getServiceAccess().getName();
|
|
serviceId=policy.getServiceAccess().getServiceId();
|
|
}
|
|
Service service =new Service(serviceClass,serviceName,serviceId);
|
|
Calendar creationTime = policy.getCreationTime();
|
|
|
|
Date dataInsert = creationTime.getTime();
|
|
Calendar lastUpdateTime = policy.getLastUpdateTime();
|
|
Date dataUpdate = lastUpdateTime.getTime();
|
|
Access access= Access.valueOf(policy.getMode().toString());
|
|
PolicyAuth policyAuth =new PolicyAuth(idpolicy,callers,excludeCallers,service,access,dataInsert,dataUpdate);
|
|
logger.debug("traduce into a policy auth:"+policyAuth.toString());
|
|
policyList.add(policyAuth);
|
|
}
|
|
}
|
|
}
|
|
return policyList;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("loadListPolicy error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load all caller
|
|
*/
|
|
@Override
|
|
public ArrayList<Caller> loadListCaller() throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
@SuppressWarnings("unused")
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
ArrayList<Caller> callers =new ArrayList<Caller>();
|
|
String token =aslSession.getSecurityToken();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
token=ConstantsSharing.DEBUG_TOKEN;
|
|
}
|
|
SecurityTokenProvider.instance.set(token);
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
logger.trace("List Caller on debug mode");
|
|
callers.add(new Caller(TypeCaller.role,"administrator"));
|
|
callers.add(new Caller(TypeCaller.user,"lucio.lelii"));
|
|
callers.add(new Caller(TypeCaller.role,"agent"));
|
|
callers.add(new Caller(TypeCaller.user,"luca.frosini"));
|
|
callers.add(new Caller(TypeCaller.user,"giancarlo.panichi"));
|
|
callers.add(new Caller(TypeCaller.role,"user"));
|
|
callers.add(new Caller(TypeCaller.service,"InformationSystem:IC:all"));
|
|
callers.add(new Caller(TypeCaller.service,"InformationSystem:IRegisrty:all"));
|
|
}
|
|
else{
|
|
RoleManager roleManager = new LiferayRoleManager();
|
|
UserManager userManager = new LiferayUserManager();
|
|
String scope=SessionUtil.getASLSession(session).getScope();
|
|
GroupManager groupManager= new LiferayGroupManager();
|
|
Long groupId= groupManager.getGroupIdFromInfrastructureScope(scope);
|
|
for (GCubeUser user :userManager.listUsersByGroup(groupId)){
|
|
callers.add(new Caller(TypeCaller.user,user.getUsername()));
|
|
}
|
|
//List All roles
|
|
for (GCubeRole role :roleManager.listAllGroupRoles()){
|
|
callers.add(new Caller(TypeCaller.role,role.getRoleName()));
|
|
}
|
|
//List Service
|
|
SimpleQuery query = queryFor(GCoreEndpoint.class);
|
|
query.setResult("<Service><ServiceClass>{$resource/Profile/ServiceClass/text()}</ServiceClass>" +
|
|
"<ServiceName>{$resource/Profile/ServiceName/text()}</ServiceName></Service>");
|
|
|
|
DiscoveryClient<ServiceResult> client = clientFor(ServiceResult.class);
|
|
List<ServiceResult> resources = client.submit(query);
|
|
for (ServiceResult result: resources){
|
|
callers.add(new Caller(TypeCaller.service,result.getServiceClass()+":"+result.getServiceName()));
|
|
}
|
|
}
|
|
return callers;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("loadListCaller error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage(),e);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Load all service
|
|
*/
|
|
@Override
|
|
public Map<String, List<String>> loadListService() throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
@SuppressWarnings("unused")
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
Map<String, List<String>> services =new HashMap<String, List<String>>();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
String token=ConstantsSharing.DEBUG_TOKEN;
|
|
SecurityTokenProvider.instance.set(token);
|
|
}
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
services.put("InformationSystem", Arrays.asList("IC", "ISRegistry"));
|
|
services.put("DataAccess", Arrays.asList("SpeciesProductsDiscovery","dAAaCCESS@"));
|
|
services.put("DataAnalysis", Arrays.asList("StatisticalManager"));
|
|
}
|
|
else{
|
|
//Get List service
|
|
SimpleQuery query = queryFor(GCoreEndpoint.class);
|
|
query.setResult("<Service><ServiceClass>{$resource/Profile/ServiceClass/text()}</ServiceClass>" +
|
|
"<ServiceName>{$resource/Profile/ServiceName/text()}</ServiceName></Service>");
|
|
DiscoveryClient<ServiceResult> client = clientFor(ServiceResult.class);
|
|
|
|
List<ServiceResult> resources = client.submit(query);
|
|
for (ServiceResult result: resources){
|
|
if (!services.containsKey(result.getServiceClass()))
|
|
services.put(result.getServiceClass(),new ArrayList<String>());
|
|
services.get(result.getServiceClass()).add(result.getServiceName());
|
|
}
|
|
}
|
|
return services;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("loadListService error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load all access
|
|
*/
|
|
@Override
|
|
public ArrayList<String> loadListAccess() throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
@SuppressWarnings("unused")
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
String token=ConstantsSharing.DEBUG_TOKEN;
|
|
SecurityTokenProvider.instance.set(token);
|
|
}
|
|
ArrayList<String> access =new ArrayList<String>();
|
|
for( Access accessValue : Access.values() )
|
|
access.add(access.toString());
|
|
return access;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("loadListAccess error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Insert a new List Policy
|
|
* @return
|
|
* @throws Throwable
|
|
*/
|
|
@Override
|
|
public void addPolicies(List<PolicyAuth> policiesAuth) throws ServiceException {
|
|
try {
|
|
//Long identifier;
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
List<Policy> policies = new ArrayList<Policy>();
|
|
String token =aslSession.getSecurityToken();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
token=ConstantsSharing.DEBUG_TOKEN;
|
|
|
|
}
|
|
SecurityTokenProvider.instance.set(token);
|
|
String scope=SessionUtil.getASLSession(session).getScope();
|
|
for (PolicyAuth policy: policiesAuth){
|
|
ServiceAccess service=new ServiceAccess(policy.getService().getServiceName(), policy.getService().getServiceClass(), policy.getService().getServiceId());
|
|
Action access =Action.valueOf(policy.getAccessString());
|
|
logger.debug("policy translate:"+policy.getCallerTypeAsString());
|
|
if (policy.getCallerTypeAsString().equalsIgnoreCase(TypeCaller.user.toString())){
|
|
logger.debug("add policy with user");
|
|
policies.add(new User2ServicePolicy(scope, service, Users.one(policy.getCallerAsString()), access ));
|
|
}
|
|
else if (policy.getCallerTypeAsString().equalsIgnoreCase(TypeCaller.role.toString())){
|
|
logger.debug("add policy with role");
|
|
policies.add(new User2ServicePolicy(scope, service, Roles.one(policy.getCallerAsString()), access ));
|
|
}
|
|
else if (policy.getCallerTypeAsString().equalsIgnoreCase(TypeCaller.service.toString())){
|
|
logger.debug("add policy with service");
|
|
String[] policyService=policy.getCallerAsString().split(":");
|
|
String serviceName=policyService[0].trim();
|
|
String serviceClass=policyService[1].trim();
|
|
String serviceId="All";
|
|
if (policyService.length==3)
|
|
serviceId=policy.getCallerAsString().split(":")[2];
|
|
ServiceAccess serviceCaller =new ServiceAccess(serviceName, serviceClass, serviceId);
|
|
policies.add(new Service2ServicePolicy(scope,service,Services.specialized(serviceCaller),access));
|
|
}
|
|
else{
|
|
String[] allExecpt=policy.getCallerTypeAsString().trim().split(" ");
|
|
if (allExecpt.length>0){
|
|
if (allExecpt[0].equalsIgnoreCase(TypeCaller.user.toString())){
|
|
logger.debug("add policy with user execpt");
|
|
policies.add(new User2ServicePolicy(scope, service, Users.allExcept(policy.getCallerExecptAsString()), access ));
|
|
}
|
|
else if (allExecpt[0].equalsIgnoreCase(TypeCaller.role.toString())){
|
|
logger.debug("add policy with role execpt");
|
|
policies.add(new User2ServicePolicy(scope, service, Roles.allExcept(policy.getCallerExecptAsString()), access ));
|
|
}
|
|
else{
|
|
logger.error("ERROR caller type not recognized"+allExecpt[0]);
|
|
throw new TypeCallerException("Caller type not found");
|
|
}
|
|
}
|
|
else{
|
|
logger.error("ERROR caller type not recognized"+policy.getCallerTypeAsString());
|
|
throw new TypeCallerException("Caller type not found");
|
|
}
|
|
}
|
|
}
|
|
logger.info("INSERT CALLER:"+policies.toString());
|
|
authorizationService().addPolicies(policies);
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Exception e) {
|
|
logger.error("addPolicies error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update an existing policy
|
|
*/
|
|
@Override
|
|
public void updatePolicy(PolicyAuth policy) throws ServiceException{
|
|
try {
|
|
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
String token =aslSession.getSecurityToken();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
token=ConstantsSharing.DEBUG_TOKEN;
|
|
}
|
|
SecurityTokenProvider.instance.set(token);
|
|
//remove old policy
|
|
authorizationService().removePolicies(policy.getIdpolicy());
|
|
//add a new policy
|
|
List<Policy> policies = new ArrayList<Policy>();
|
|
String scope=SessionUtil.getASLSession(session).getScope();
|
|
ServiceAccess service=new ServiceAccess(policy.getService().getServiceName(), policy.getService().getServiceClass(), policy.getService().getServiceId());
|
|
logger.info("updatePolicy -policy.getCallerAsString()"+policy.getCallerAsString());
|
|
Action access =Action.valueOf(policy.getAccessString());
|
|
policies.add(new User2ServicePolicy(scope, service, Users.one(policy.getCallerAsString()), access ));
|
|
authorizationService().addPolicies(policies);
|
|
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
logger.error("updatePolicy error: " + e.getLocalizedMessage(), e);
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
public List<Long> deletePolicies(List<Long> identifiers)throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
ArrayList<PolicyAuth> policy =new ArrayList<PolicyAuth>();
|
|
String token =aslSession.getSecurityToken();
|
|
if (ConstantsSharing.DEBUG_MODE) {
|
|
token=ConstantsSharing.DEBUG_TOKEN;
|
|
}
|
|
SecurityTokenProvider.instance.set(token);
|
|
for (Long identifier:identifiers){
|
|
logger.info("Remove policy idpolicy "+identifier);
|
|
authorizationService().removePolicies(identifier);
|
|
}
|
|
return identifiers;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("deletePolicies error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Load all list quota
|
|
*/
|
|
@Override
|
|
public ArrayList<Quote> loadListQuota() throws ServiceException {
|
|
try {
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
SessionUtil.getASLSession(session);
|
|
ArrayList<Quote> quote =new ArrayList<Quote>();
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
logger.info("loadListQuota");
|
|
for (Quote quoteList : TableUtils.SERVICESQUOTE.values()){
|
|
quote.add(quoteList);
|
|
}
|
|
}
|
|
else{
|
|
logger.info("loadListQuota ");
|
|
for (Quote quoteList : TableUtils.SERVICESQUOTE.values()){
|
|
|
|
quote.add(quoteList);
|
|
}
|
|
}
|
|
return quote;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("loadListQuota error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public List<Long> deleteQuote(List<Long> identifiers)throws ServiceException {
|
|
try {
|
|
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
for (Long identifier:identifiers){
|
|
logger.info("Remove quote idquote "+identifier);
|
|
TableUtils.SERVICESQUOTE.remove(identifier);
|
|
}
|
|
}
|
|
else{
|
|
for (Long identifier:identifiers){
|
|
logger.info("Remove quote idquote "+identifier);
|
|
TableUtils.SERVICESQUOTE.remove(identifier);
|
|
}
|
|
}
|
|
|
|
return identifiers;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("deleteQuote error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<Quote> addQuote(List<Quote> quote) throws ServiceException {
|
|
try {
|
|
Long identifier;
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
for (Quote quota: quote){
|
|
identifier =(long)(Math.random()*1000000000);
|
|
logger.info("Insert new quota for "+quota.getCallerAsString()+ "return with:"+identifier);
|
|
quota.setIdQuote(identifier);
|
|
Calendar calendarStart = Calendar.getInstance();
|
|
Date dateStart = calendarStart.getTime();
|
|
quota.setDataInsert(dateStart);
|
|
TableUtils.SERVICESQUOTE.put(identifier, quota);
|
|
}
|
|
}
|
|
else{
|
|
for (Quote quota: quote){
|
|
identifier =(long)(Math.random()*1000000000);
|
|
logger.info("Insert new quota for "+quota.getCallerAsString()+ "return with:"+identifier);
|
|
quota.setIdQuote(identifier);
|
|
Calendar calendarStart = Calendar.getInstance();
|
|
Date dateStart = calendarStart.getTime();
|
|
quota.setDataInsert(dateStart);
|
|
TableUtils.SERVICESQUOTE.put(identifier, quota);
|
|
}
|
|
}
|
|
return quote;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("addQuote error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Update an existing quote
|
|
*/
|
|
@Override
|
|
public Quote updateQuote(Quote quote) throws ServiceException{
|
|
try {
|
|
|
|
HttpSession session = this.getThreadLocalRequest().getSession();
|
|
ASLSession aslSession = SessionUtil.getASLSession(session);
|
|
|
|
if (ConstantsSharing.MOCK_UP) {
|
|
//TableUtils.SERVICES.
|
|
TableUtils.SERVICESQUOTE.remove(quote.getIdQuote());
|
|
|
|
Calendar calendarStart = Calendar.getInstance();
|
|
Date dateUpdate = calendarStart.getTime();
|
|
quote.setDataUpdate(dateUpdate);
|
|
|
|
TableUtils.SERVICESQUOTE.put(quote.getIdQuote(), quote);
|
|
logger.info("Update quote identifier:"+quote.getIdQuote());
|
|
}
|
|
else{
|
|
TableUtils.SERVICESQUOTE.remove(quote.getIdQuote());
|
|
Calendar calendarStart = Calendar.getInstance();
|
|
Date dateUpdate = calendarStart.getTime();
|
|
quote.setDataUpdate(dateUpdate);
|
|
TableUtils.SERVICESQUOTE.put(quote.getIdQuote(), quote);
|
|
logger.info("Update quote identifier:"+quote.getIdQuote());
|
|
}
|
|
|
|
return quote;
|
|
} catch (ServiceException e) {
|
|
logger.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
throw e;
|
|
} catch (Throwable e) {
|
|
logger.error("updateQuote error: " + e.getLocalizedMessage(), e);
|
|
e.printStackTrace();
|
|
throw new ServiceException(e.getLocalizedMessage());
|
|
}
|
|
|
|
}
|
|
|
|
}
|