The requestaction again :)
| package cz.bpsolutions.mis.request;
|
| import java.io.Serializable;
| import java.util.ArrayList;
| import java.util.Calendar;
| import java.util.Collection;
| import java.util.Date;
| import java.util.List;
|
| import javax.ejb.Remove;
| import javax.ejb.Stateful;
| import javax.persistence.EntityManager;
| import javax.persistence.PersistenceContext;
| import javax.persistence.PersistenceContextType;
|
| import org.hibernate.Criteria;
| import org.hibernate.criterion.Disjunction;
| import org.hibernate.criterion.MatchMode;
| import org.hibernate.criterion.Restrictions;
| import org.hibernate.ejb.EntityManagerImpl;
| import org.jboss.annotation.ejb.cache.simple.CacheConfig;
| import org.jboss.seam.ScopeType;
| import org.jboss.seam.annotations.Begin;
| import org.jboss.seam.annotations.Destroy;
| import org.jboss.seam.annotations.End;
| import org.jboss.seam.annotations.Factory;
| import org.jboss.seam.annotations.FlushModeType;
| import org.jboss.seam.annotations.In;
| import org.jboss.seam.annotations.Logger;
| import org.jboss.seam.annotations.Name;
| import org.jboss.seam.annotations.Out;
| import org.jboss.seam.annotations.datamodel.DataModel;
| import org.jboss.seam.annotations.datamodel.DataModelSelection;
| import org.jboss.seam.annotations.security.Restrict;
| import org.jboss.seam.log.Log;
| import org.jboss.seam.security.Identity;
|
| import cz.bpsolutions.ims.actions.request.RequestServiceLocal;
| import cz.bpsolutions.ims.beans.Reason;
| import cz.bpsolutions.ims.beans.Solution;
| import cz.bpsolutions.ims.beans.UploadedFile;
| import cz.bpsolutions.ims.model.Account;
| import cz.bpsolutions.ims.model.Attachement;
| import cz.bpsolutions.ims.model.Category;
| import cz.bpsolutions.ims.model.Request;
| import cz.bpsolutions.ims.model.RequestFilter;
| import cz.bpsolutions.ims.model.RequestType;
| import cz.bpsolutions.ims.service.request.RequestSearchParams;
| import cz.bpsolutions.ims.workflow.RequestState;
| import cz.bpsolutions.seam.validation.method.annotation.CustomValidator;
| import cz.bpsolutions.seam.validation.method.annotation.ValidatedMethod;
| import cz.bpsolutions.tools.StringTools;
|
| @Name("requestAction")
| @Stateful
| @Restrict("#{identity.loggedIn}")
| public class RequestAction implements RequestActionLocal, Serializable {
|
| private static final long serialVersionUID = -5653139064486044176L;
|
| @PersistenceContext(type = PersistenceContextType.EXTENDED)
| EntityManager em;
|
| @Logger
| Log log;
|
| @DataModelSelection(value = "requestActionList")
| @In(required = false)
| @Out(required = false, scope = ScopeType.CONVERSATION)
| private Request request;
|
| @DataModelSelection(value = "requestAction_attachements")
| private Attachement attachement;
|
| @DataModel(scope = ScopeType.PAGE)
| private Collection<Request> requestActionList;
|
| @In(create = true)
| private RequestServiceLocal requestService;
|
| @DataModel()
| private Collection<Attachement> requestAction_attachements;
|
| @In(required = false)
| private UploadedFile uploadedFile;
|
| @In(required = false)
| private Category category;
|
| @In(required = false)
| @Out(required = false)
| private Reason reason;
|
| @In(scope = ScopeType.SESSION, value = "loggedUser")
| Account loggedUser;
|
| @In(required = false)
| private RequestType requestType;
|
| @In(required = false)
| private RequestSearchParams requestSearchParams;
|
| @In(required = false)
| @Out(required = false)
| Solution solution;
|
| @DataModel
| List<Account> requestAction_solvers;
|
| @DataModelSelection("requestAction_solvers")
| Account selectedUser;
|
| @DataModel()
| List<RequestFilter> requestAction_filters;
|
| @DataModelSelection("requestAction_filters")
| @In(required = false)
| @Out(required = false)
| RequestFilter requestFilter;
|
| @In(required = false)
| String parReqId;
|
| @In(required = false, scope = ScopeType.SESSION)
| @Out(required = false, scope = ScopeType.SESSION)
| RequestFilter rf;
|
| @Factory("requestAction_solvers")
| public void initSolvers() {
| log.info("loading solvers for the request: #0", request);
| requestAction_solvers = ((EntityManagerImpl) (em.getDelegate()))
|
.getSession().createCriteria(Account.class).list();
| }
|
| @Factory("requestAction_attachements")
| public void initAttachements() {
| log.info("loading the attachements");
| if (request != null) {
| requestAction_attachements = request.getAttachements();
| }
| }
|
| @Factory("requestActionList")
| public void init() {
| log.info("loading all requests, filter: #0", rf);
|
| Criteria cr = ((EntityManagerImpl)
(em.getDelegate())).getSession()
| .createCriteria(Request.class);
|
| if (rf != null) {
|
| // restrikce autora
| if (!StringTools.isEmpty(rf.getAuthorName())) {
| log.info("finding author: #0",
rf.getAuthorName());
| cr.createAlias("author", "a");
| cr.add(Restrictions.ilike("a.fullName",
rf.getAuthorName(),
| MatchMode.ANYWHERE));
| }
| // restrikce resitele
| if (!StringTools.isEmpty(rf.getSolverName())) {
| log.info("finding solver: #0",
rf.getSolverName());
| cr.createAlias("solver", "s");
| cr.add(Restrictions.ilike("s.fullName",
rf.getSolverName(),
| MatchMode.ANYWHERE));
| }
| // restrikce operatora
| if (!StringTools.isEmpty(rf.getOperatorName())) {
| log.info("finding operator: #0",
rf.getOperatorName());
| cr.createAlias("operator", "o");
| cr.add(Restrictions.ilike("o.fullName",
rf.getOperatorName(),
| MatchMode.ANYWHERE));
| }
|
| // restrikce kategorii
| if (!StringTools.isEmpty(rf.getCategoriesString())) {
| log.info("finding category: #0",
rf.getCategoriesString());
| cr.createAlias("category", "cat");
| Disjunction rs = Restrictions.disjunction();
| for (String catId :
rf.getCategoriesString().split(",")) {
| Category cat = (Category)
em.find(Category.class, Long
| .valueOf(catId));
| if (cat != null) {
|
rs.add(Restrictions.ilike("cat.fullName", cat
| .getFullName(),
MatchMode.ANYWHERE));
| }
| }
| cr.add(rs);
| }
|
| // restrikce stavu
| if (!StringTools.isEmpty(rf.getStatesString())) {
| log.info("finding states: #0",
rf.getStatesString());
| Disjunction rs = Restrictions.disjunction();
|
| for (String state :
rf.getStatesString().split(",")) {
| rs.add(Restrictions.eq("state", state));
| }
| cr.add(rs);
| }
|
| // restrikce nazvu a popisu
| if (!StringTools.isEmpty(rf.getKeyword())) {
| log.info("finding keyword: #0",
rf.getKeyword());
| cr.add(Restrictions.disjunction().add(
| Restrictions.ilike("name",
rf.getKeyword(),
|
MatchMode.ANYWHERE)).add(
|
Restrictions.ilike("description", rf.getKeyword(),
|
MatchMode.ANYWHERE)));
| }
|
| // restrikce requestTypu
| if (!StringTools.isEmpty(rf.getRequestTypesString())) {
| log.info("finding requestType: #0",
rf.getRequestTypesString());
| cr.createAlias("requestType", "rt");
| Disjunction dj = Restrictions.disjunction();
|
| for (String rt :
rf.getRequestTypesString().split(",")) {
| dj.add(Restrictions.eq("rt.id",
Long.valueOf(rt)));
| }
| cr.add(dj);
| }
| // restrikce priority
| if (!StringTools.isEmpty(rf.getPrioritiesString())) {
| log.info("finding priority: #0",
rf.getPrioritiesString());
| Disjunction rs = Restrictions.disjunction();
|
| for (String priority :
rf.getPrioritiesString().split(",")) {
| rs.add(Restrictions.eq("priority",
Integer
| .valueOf(priority)));
| }
| cr.add(rs);
| }
|
| // restrikce datumu
| if (rf.getDateFilter() != null &&
!rf.getDateFilter().equals(0)) {
| if (rf.getDateFilter() == 1) {
| // dnes
| Date today = new Date();
|
| Calendar cal = Calendar.getInstance();
|
| cal.setTime(today);
|
| cal.set(Calendar.HOUR, 0);
| cal.set(Calendar.MINUTE, 0);
| cal.set(Calendar.SECOND, 0);
| cal.set(Calendar.MILLISECOND, 0);
|
| Date from = cal.getTime();
|
| cal.set(Calendar.HOUR, 23);
| cal.set(Calendar.MINUTE, 59);
| cal.set(Calendar.SECOND, 59);
|
| Date to = cal.getTime();
|
| cr.add(Restrictions.between("created",
from, to));
| }
| if (rf.getDateFilter() == 2) {
| // 3 dny
| Date today = new Date();
|
| Calendar cal = Calendar.getInstance();
|
| cal.setTime(today);
|
| cal.set(Calendar.HOUR, 23);
| cal.set(Calendar.MINUTE, 59);
| cal.set(Calendar.SECOND, 59);
| Date to = cal.getTime();
|
| cal.set(Calendar.HOUR, 0);
| cal.set(Calendar.MINUTE, 0);
| cal.set(Calendar.SECOND, 0);
| cal.set(Calendar.MILLISECOND, 0);
|
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| Date from = cal.getTime();
|
| cr.add(Restrictions.between("created",
from, to));
| }
| if (rf.getDateFilter() == 3) {
| Date today = new Date();
|
| Calendar cal = Calendar.getInstance();
|
| cal.setTime(today);
|
| cal.set(Calendar.HOUR, 23);
| cal.set(Calendar.MINUTE, 59);
| cal.set(Calendar.SECOND, 59);
| Date to = cal.getTime();
|
| cal.set(Calendar.HOUR, 0);
| cal.set(Calendar.MINUTE, 0);
| cal.set(Calendar.SECOND, 0);
| cal.set(Calendar.MILLISECOND, 0);
|
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| cal.add(Calendar.HOUR, -24);
| Date from = cal.getTime();
|
| cr.add(Restrictions.between("created",
from, to));
| }
| if (rf.getDateFilter() == 4) {
| cr.add(Restrictions.between("created",
rf.getFromDate(), rf
| .getToDate()));
| }
| }
| requestActionList = cr.list();
|
| } else {
| requestActionList = cr.list();
| }
| log.info("raw collection size: #0", requestActionList.size());
|
| for (Request r : new ArrayList<Request>(requestActionList)) {
| if (!Identity.instance().hasPermission("request",
"read", r)) {
| requestActionList.remove(r);
| }
| }
| log.info("secured collection size: #0",
requestActionList.size());
|
| }
|
| public String find() {
| log.info("finding the requests");
| requestActionList = null;
| return "find";
| }
|
| public String delete() {
| log.info("deleting the request: #0", request);
| em.remove(request);
| requestActionList = null;
| return DefaultActions.DELETED;
| }
|
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "addForm", validators = {
@CustomValidator(validatorClass = RequestSaveValidator.class, mapping = {
| "category", "requestType", "request" }) })
| public String save() {
| log.info("adding the request #0", request);
| em.refresh(category);
| em.refresh(requestType);
|
| requestType.getRequests().add(request);
|
| request.setCategory(category);
| request.setAuthor(loggedUser);
| request.setCreated(new Date());
| request.setRequestType(requestType);
|
| if (parReqId != null) { // podrizeny request - nastavime vazby
a ulozime
| // rodice
| Request parentRequest = em.find(Request.class, Long
| .valueOf(parReqId));
| request.setParent(parentRequest);
| parentRequest.getChildren().add(request);
| em.merge(parentRequest);
| parReqId = null; // pro jistotu
| }
| em.merge(request);
|
| requestService.save(request);
| return DefaultActions.SAVED;
| }
|
| @ValidatedMethod(formName = "editForm", validators = {
@CustomValidator(validatorClass = RequestSaveValidator.class, mapping = {
| "category", "requestType", "request" }) })
| @End(beforeRedirect = true)
| public String update() {
| log.info("adding the request #0", request);
| em.refresh(category);
| em.refresh(requestType);
|
| if (!requestType.getRequests().contains(request)) {
| requestType.getRequests().add(request);
| }
| request.setCategory(category);
| request.setAuthor(loggedUser);
| request.setCreated(new Date());
| request.setRequestType(requestType);
|
| em.merge(request);
| return DefaultActions.EDITED;
| }
|
| @Begin(join = true)
| public String loadDetail() {
| edit();
| return DefaultActions.LOADED;
| }
|
| @Begin(join = true)
| public String edit() {
| em.refresh(request);
| requestAction_attachements = request.getAttachements();
| return DefaultActions.EDITED;
| }
|
| @Begin(join = true)
| public String addAttachement() {
| checkRequest();
| log.info("adding attachement #0: #1", request, uploadedFile);
|
| if (uploadedFile == null) {
| return null;
| }
|
| String location = uploadedFile.getUploadedFile().getName()
| + (new Date()).toString();
|
| Attachement a = new Attachement();
|
a.setContentType(uploadedFile.getUploadedFile().getContentType());
| a.setFileName(uploadedFile.getUploadedFile().getName());
| a.setFileSize(uploadedFile.getUploadedFile().getSize());
| a.setRequest(request);
| a.setLocation(location);
|
| request.getAttachements().add(a);
| requestAction_attachements = request.getAttachements();
|
| return "attachementAdded";
| }
|
| @Begin(join = true)
| public String removeAttachement() {
| checkRequest();
| log.info("removing attachement #0", request);
|
| request.getAttachements().remove(attachement);
| requestAction_attachements = request.getAttachements();
|
| return "attachementRemoved";
| }
|
| private void checkRequest() {
| if (request == null) {
| request = new Request();
| }
| }
|
| @Destroy
| @Remove
| public void destroy() {
| }
|
| /**
| * Tato metoda je volaná kdy? chce autor akceptovat vy?e?ení HelpDesku.
| * Metoda je kone?ná.
| */
| @Begin(join = true)
| public String authAcceptSolution() {
| requestService.authAcceptSolution(request);
| return null;
| }
|
| /**
| * Tato metoda je volaná kdy? chce autor odmítnout (reklamovat)
validované
| * ?e?ení. Metoda p?esm?rovává na stránku se zadáním d?vodu.
| */
| @Begin(join = true)
| public String authRejectSolution() {
| reason = new Reason();
| return "rejectSolution";
| }
|
| /**
| * Tato metoda je volaná kdy? chce autor odmítnout (reklamovat)
validované
| * ?e?ení. Metoda se zavolá ze stránky, která definovala d?vod pro
odmítnutí
| * ?e?ení.
| */
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "rejectForm", validators = {
@CustomValidator(validatorClass = ReasonValidator.class, mapping = "reason") })
| public String authSaveRejectSolution() {
| requestService.authSaveRejectSolution(request, reason);
| return "rejectedSolution";
| }
|
| /**
| * Tato metoda nastaví operátor?v souhlas s autorovou reklamací. Vrací
| * po?adavek zp?t do stavu "?e?í se"
| */
| @End(beforeRedirect = true)
| public String opAcceptReclamation() {
| requestService.opAcceptReclamation(request);
| return null;
| }
|
| /**
| * Tato metoda nastavuje validaci operátora s vy?e?ením po?adavku.
| */
| @End(beforeRedirect = true)
| public String opAcceptSolution() {
| requestService.opAcceptSolution(request);
| return null;
| }
|
| /**
| * Tato metoda posíla p?esm?rování na solverselect.xhtml, kde se zobrazí
| * v?ichni ?e?itelé.
| */
| @Begin(join = true)
| public String opAssignSolver() {
| log.info("forwarding to select solver...");
| return "selectSolver";
| }
|
| /**
| * Tato metoda zajistí ulo?ení vybraného ?e?itele. Odskakuje zp?t na
| * /actions/request/list.xhtml
| */
| @End(beforeRedirect = true)
| public String opSaveAssignSolver() {
| log.info("saving the assigned solver...");
| requestService.opSaveAssignSolver(request, selectedUser);
| return "solverSelected";
| }
|
| /**
| * Tato metoda provede p?esm?rování na stránku pro zadání od?vodn?ní
| * nesouhlasu s autorovou reklamací.
| */
| @Begin(join = true)
| public String opRejectReclamation() {
| log.info("redirecting to the rejectreclamation");
| return "rejectReclamation";
| }
|
| /**
| * Tato metoda zavolá servisku pro odmítnutí u?ivatelské reklamace.
| */
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "rejectForm", validators = {
@CustomValidator(validatorClass = ReasonValidator.class, mapping = "reason") })
| public String opSaveRejectReclamation() {
| requestService.opSaveRejectReclamation(request, reason);
| return "rejectReclamationSaved";
| }
|
| /**
| * Tato metoda zajistí p?esm?rování na zadání d?vodu pro odmítnutí
po?adaku.
| */
| @Begin(join = true)
| public String opRejectRequest() {
| log.info("forwarding to request reject.");
| return "rejectRequest";
| }
|
| /**
| * Tato metoda zajistí zapsání informace o odmítnutí a odmítnutí
po?adavku.
| */
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "rejectForm", validators = {
@CustomValidator(validatorClass = ReasonValidator.class, mapping = "reason") })
| public String opSaveRejectRequest() {
| requestService.opSaveRejectRequest(request, reason);
| return "rejectRequestSaved";
| }
|
| public String opRejectSolution() {
| request.setState(RequestState.SOLVING);
| em.merge(request);
| return "returnToSolving";
| }
|
| @End(beforeRedirect = true)
| public String opSaveRejectSolution() {
| // TODO Auto-generated method stub
| return "returnedToSolving";
| }
|
| /** nastavi stav v reseni */
| @End(beforeRedirect = true)
| public String solvAcceptAssignment() {
| requestService.solvAcceptAssignment(request);
| return "";
| }
|
| /**
| * Tato metoda provede p?esm?rování na formulá? zadávající d?vod pro?
| * ?e?itel odmítl po?adavek.
| */
| @Begin(join = true)
| public String solvRejectAssignment() {
| log.info("redirecting to the reject solving");
| reason = new Reason();
| return "rejectAssignment";
| }
|
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "rejectForm", validators = {
@CustomValidator(validatorClass = ReasonValidator.class, mapping = "reason") })
| public String solvSaveRejectAssignment() {
| requestService.solvSaveRejectAssignment(request, reason);
| return "rejectAssignmentSaved";
| }
|
| /**
| * Tato metoda p?epo?le ?e?itele na zadání ?e?ení.
| */
| @Begin(join = true)
| public String solvSolveRequest() {
| log.info("redirecting to the add solution");
| em.refresh(request);
| return "solveRequest";
| }
|
| /**
| * Tato metoda ulo?í vy?e?ení, nebo p?idá ?e?ení ke stávajícímu
| */
| @End(beforeRedirect = true)
| @ValidatedMethod(formName = "solveForm", validators = {
@CustomValidator(validatorClass = SolutionValidator.class, mapping = "request")
})
| public String solvSaveSolveRequest() {
| requestService.solvSolveRequest(request, solution);
| return "solutionSaved";
| }
|
| /**
| * Tato metoda p?eposílá na správu filtr?
| */
| public String manageFilters() {
| return "manageFilters";
| }
|
| @Factory("requestAction_filters")
| public void initFilters() {
| requestAction_filters = ((EntityManagerImpl) (em.getDelegate()))
|
.getSession().createCriteria(RequestFilter.class).createAlias(
| "account", "a").add(
| Restrictions.eq("a.id",
loggedUser.getId())).list();
| log.info("loading user filters for request: #0",
requestAction_filters);
| }
|
| public String setFilter(Long id) {
| log.info("trying to set filter #0", id);
| rf = (RequestFilter) em.find(RequestFilter.class, id);
| log.info("succesfully loaded filter: #0", rf);
| requestActionList = null;
| return "list";
| }
|
| public String deleteFilter() {
| log.info("deleting filter #0", requestFilter);
| Account a = (Account) em.find(Account.class,
requestFilter.getAccount()
| .getId());
| // a.getFilters().remove(requestFilter);
| em.remove(requestFilter);
| em.merge(a);
|
| requestAction_filters = null;
| return "filterDeleted";
| }
|
| public void initAddChildren() {
| if (parReqId != null) {
| request = null;
| }
| }
|
| @Begin(nested = true)
| public String addFilter() {
| return "addFilter";
| }
|
| @End(beforeRedirect = true)
| public String saveFilter() {
| requestFilter.setAccount(loggedUser);
| Account a = em.find(Account.class, loggedUser.getId());
|
| a.getFilters().add(requestFilter);
| em.refresh(a);
|
| em.merge(requestFilter);
| em.merge(a);
| requestAction_filters = null;
| requestFilter = null;
| return "filterSaved";
| }
|
| public String editFilter() {
| return "editFilter";
| }
|
| public String removeFilter() {
| return null;
| }
|
| public String updateFilter() {
| return "filterSaved";
| }
|
| public String cancelFilter() {
| rf = null;
| requestActionList = null;
| return "list";
| }
| }
|
|
View the original post :
http://www.jboss.com/index.html?module=bb&op=viewtopic&p=4085214#4085214
Reply to the post :
http://www.jboss.com/index.html?module=bb&op=posting&mode=reply&p=4085214
_______________________________________________
jboss-user mailing list
[email protected]
https://lists.jboss.org/mailman/listinfo/jboss-user
