VersionHome.java

/*
 *
 *  * Copyright 2014, Red Hat, Inc. and individual contributors as indicated by the
 *  * @author tags. See the copyright.txt file in the distribution for a full
 *  * listing of individual contributors.
 *  *
 *  * This is free software; you can redistribute it and/or modify it under the
 *  * terms of the GNU Lesser General Public License as published by the Free
 *  * Software Foundation; either version 2.1 of the License, or (at your option)
 *  * any later version.
 *  *
 *  * This software is distributed in the hope that it will be useful, but WITHOUT
 *  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 *  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 *  * details.
 *  *
 *  * You should have received a copy of the GNU Lesser General Public License
 *  * along with this software; if not, write to the Free Software Foundation,
 *  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA, or see the FSF
 *  * site: http://www.fsf.org.
 */
package org.zanata.action;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
import javax.faces.event.ValueChangeEvent;
import javax.persistence.EntityNotFoundException;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Session;
import org.hibernate.criterion.NaturalIdentifier;
import org.hibernate.criterion.Restrictions;
import org.jboss.seam.Component;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.security.Restrict;
import org.jboss.seam.core.Events;
import org.jboss.seam.faces.FacesMessages;
import org.jboss.seam.international.StatusMessage;
import org.zanata.common.EntityStatus;
import org.zanata.common.ProjectType;
import org.zanata.dao.ProjectDAO;
import org.zanata.model.HLocale;
import org.zanata.model.HProject;
import org.zanata.model.HProjectIteration;
import org.zanata.seam.scope.FlashScopeBean;
import org.zanata.service.LocaleService;
import org.zanata.service.SlugEntityService;
import org.zanata.service.ValidationService;
import org.zanata.service.impl.LocaleServiceImpl;
import org.zanata.util.ZanataMessages;
import org.zanata.webtrans.shared.model.ValidationAction;
import org.zanata.webtrans.shared.model.ValidationId;
import org.zanata.webtrans.shared.validation.ValidationFactory;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

@Name("versionHome")
@Slf4j
public class VersionHome extends SlugHome<HProjectIteration> {

    private static final long serialVersionUID = 1L;

    public static final String PROJECT_ITERATION_UPDATE =
            "project.iteration.update";

    @Getter
    @Setter
    private String slug;

    @Getter
    @Setter
    private String projectSlug;

    @In
    private FlashScopeBean flashScope;

    @In(required = false)
    Map<String, String> iterationCustomizedItems;

    @In(required = false)
    private Boolean iterationOverrideLocales;

    @In
    private LocaleService localeServiceImpl;

    @In
    private ValidationService validationServiceImpl;

    @In
    private SlugEntityService slugEntityServiceImpl;

    @In(create = true)
    private ProjectDAO projectDAO;

    @In
    private ZanataMessages zanataMessages;

    private Map<ValidationId, ValidationAction> availableValidations = Maps
            .newHashMap();

    @Override
    protected HProjectIteration loadInstance() {
        Session session = (Session) getEntityManager().getDelegate();
        if (!StringUtils.isEmpty(getSlug())) {
            return (HProjectIteration) session
                    .byNaturalId(HProjectIteration.class)
                    .using("slug", getSlug())
                    .using("project", projectDAO.getBySlug(projectSlug)).load();
        } else {
            // new version
            HProjectIteration iteration = new HProjectIteration();
            HProject project = (HProject) projectDAO.getBySlug(projectSlug);
            project.addIteration(iteration);
            iteration.setProjectType(project.getDefaultProjectType());
            if (project.isOverrideLocales()) {
                iteration.setOverrideLocales(project.isOverrideLocales());
                iteration.setCustomizedLocales(project.getCustomizedLocales());
            }
            iteration.getCustomizedValidations().putAll(
                    project.getCustomizedValidations());
            return iteration;
        }
    }

    @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
    public void updateRequireTranslationReview(String key, boolean checked) {
        getInstance().setRequireTranslationReview(checked);
        update();
        if (checked) {
            addMessage(StatusMessage.Severity.INFO,
                    zanataMessages
                            .getMessage("jsf.iteration.requireReview.enabled"));
        } else {
            addMessage(StatusMessage.Severity.INFO,
                    zanataMessages
                            .getMessage("jsf.iteration.requireReview.disabled"));
        }
    }

    @Getter
    private AbstractAutocomplete<HLocale> localeAutocomplete =
            new AbstractAutocomplete<HLocale>() {

                private LocaleService localeServiceImpl =
                        (LocaleService) Component
                                .getInstance(LocaleServiceImpl.class);

                private ZanataMessages zanataMessages =
                        (ZanataMessages) Component
                                .getInstance(ZanataMessages.class);

                private boolean isIncludeLocale(HLocale input) {
                    return !getInstance().getCustomizedLocales()
                            .contains(input)
                            && (input.getLocaleId().getId()
                                    .startsWith(getQuery()) || input
                                    .retrieveDisplayName().toLowerCase()
                                    .contains(getQuery().toLowerCase()));
                }

                @Override
                public List<HLocale> suggest() {
                    if (StringUtils.isEmpty(getQuery())
                            || !getInstance().isOverrideLocales()) {
                        return Lists.newArrayList();
                    } else {
                        List<HLocale> localeList =
                                localeServiceImpl.getSupportedLocales();
                        Collection<HLocale> filtered =
                                Collections2.filter(localeList,
                                        new Predicate<HLocale>() {
                                            @Override
                                            public boolean apply(
                                                    @Nullable HLocale input) {
                                                return isIncludeLocale(input);
                                            }
                                        });
                        return Lists.newArrayList(filtered);
                    }
                }

                @Override
                @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
                public void onSelectItemAction() {
                    if (StringUtils.isEmpty(getSelectedItem())) {
                        return;
                    }

                    HLocale locale =
                            localeServiceImpl.getByLocaleId(getSelectedItem());

                    if (!getInstance().isOverrideLocales()) {
                        getInstance().setOverrideLocales(true);
                        getInstance().getCustomizedLocales().clear();
                    }
                    getInstance().getCustomizedLocales().add(locale);

                    update();
                    reset();

                    addMessage(StatusMessage.Severity.INFO,
                            zanataMessages.getMessage(
                                    "jsf.iteration.LanguageAdded",
                                    locale.retrieveDisplayName()));
                }
            };

    public List<ValidationAction> getValidationList() {
        List<ValidationAction> sortedList =
                Lists.newArrayList(getValidations().values());
        Collections.sort(sortedList,
                ValidationFactory.ValidationActionComparator);
        return sortedList;
    }

    private Map<ValidationId, ValidationAction> getValidations() {
        if (availableValidations.isEmpty()) {
            Collection<ValidationAction> validationList =
                    validationServiceImpl.getValidationActions(projectSlug,
                            slug);

            for (ValidationAction validationAction : validationList) {
                availableValidations.put(validationAction.getId(),
                        validationAction);
            }
        }

        return availableValidations;
    }

    public void validateSuppliedId() {
        getInstance(); // this will raise an EntityNotFound exception
        // when id is invalid and conversation will not
        // start
    }

    public ProjectType getProjectType() {
        if (getInstance().getProjectType() == null) {
            getInstance().setProjectType(
                    getInstance().getProject().getDefaultProjectType());
        }
        return getInstance().getProjectType();
    }

    public void setProjectType(ProjectType projectType) {
        getInstance().setProjectType(projectType);
    }

    public void validateProjectSlug() {
        if (projectDAO.getBySlug(projectSlug) == null) {
            throw new EntityNotFoundException("no entity with slug "
                    + projectSlug);
        }
    }

    public void verifySlugAvailable(ValueChangeEvent e) {
        String slug = (String) e.getNewValue();
        validateSlug(slug, e.getComponent().getId());
    }

    public boolean validateSlug(String slug, String componentId) {
        if (!isSlugAvailable(slug)) {
            FacesMessages.instance().addToControl(componentId,
                    "This Version ID has been used in this project");
            return false;
        }
        return true;
    }

    public boolean isSlugAvailable(String slug) {
        return slugEntityServiceImpl.isProjectIterationSlugAvailable(slug,
                projectSlug);
    }

    @Override
    public String persist() {
        if (!validateSlug(getInstance().getSlug(), "slug"))
            return null;

        updateOverrideLocales();

        return super.persist();
    }

    public void cancel() {
    }

    @Override
    public Object getId() {
        return projectSlug + "/" + slug;
    }

    @Override
    public NaturalIdentifier getNaturalId() {
        return Restrictions.naturalId().set("slug", slug)
                .set("project", projectDAO.getBySlug(projectSlug));
    }

    @Override
    public boolean isIdDefined() {
        return slug != null && projectSlug != null;
    }

    public List<HLocale> getInstanceActiveLocales() {
        List<HLocale> locales;
        if (getInstance().isOverrideLocales()) {
            locales = Lists.newArrayList(getInstance().getCustomizedLocales());
        } else {
            locales = localeServiceImpl.getSupportedLocales();
        }

        Collections.sort(locales, new Comparator<HLocale>() {
            @Override
            public int compare(HLocale hLocale, HLocale hLocale2) {
                return hLocale.retrieveDisplayName().compareTo(
                        hLocale2.retrieveDisplayName());
            }
        });
        return locales;
    }

    @Override
    @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
    public String update() {
        // updateOverrideLocales();
        clearMessage();
        String state = super.update();
        Events.instance().raiseEvent(PROJECT_ITERATION_UPDATE, getInstance());
        return state;
    }

    @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
    public void removeLanguage(HLocale locale) {
        if (getInstance().isOverrideLocales()) {
            getInstance().getCustomizedLocales().remove(locale);
        } else {
            getInstance().getCustomizedLocales().clear();
            for (HLocale activeLocale : getInstanceActiveLocales()) {
                if (!activeLocale.equals(locale)) {
                    getInstance().getCustomizedLocales().add(activeLocale);
                }
            }
            getInstance().setOverrideLocales(true);
        }
        update();
        addMessage(StatusMessage.Severity.INFO, zanataMessages.getMessage(
                "jsf.iteration.LanguageRemoved", locale.retrieveDisplayName()));
    }

    @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
    public void updateStatus(char initial) {
        getInstance().setStatus(EntityStatus.valueOf(initial));
        update();
        addMessage(StatusMessage.Severity.INFO, zanataMessages.getMessage(
                "jsf.iteration.status.updated", EntityStatus.valueOf(initial)));
    }

    public void setSelectedProjectType(String selectedProjectType) {
        if (!StringUtils.isEmpty(selectedProjectType)
                && !selectedProjectType.equals("null")) {
            ProjectType projectType = ProjectType.valueOf(selectedProjectType);
            getInstance().setProjectType(projectType);
        } else {
            getInstance().setProjectType(null);
        }
    }

    public List<ValidationAction.State> getValidationStates() {
        return Arrays.asList(ValidationAction.State.values());
    }

    @Restrict("#{s:hasPermission(versionHome.instance, 'update')}")
    public void updateValidationOption(String name, String state) {
        ValidationId validatationId = ValidationId.valueOf(name);

        for (Map.Entry<ValidationId, ValidationAction> entry : getValidations()
                .entrySet()) {
            if (entry.getKey().name().equals(name)) {
                getValidations().get(validatationId).setState(
                        ValidationAction.State.valueOf(state));
                ensureMutualExclusivity(getValidations().get(validatationId));
                break;
            }
            getInstance().getCustomizedValidations().put(entry.getKey().name(),
                    entry.getValue().getState().name());
        }

        update();
        addMessage(StatusMessage.Severity.INFO, zanataMessages.getMessage(
                "jsf.validation.updated", validatationId.getDisplayName(),
                state));
    }

    /**
     * If this action is enabled(Warning or Error), then it's exclusive
     * validation will be turn off
     * 
     * @param selectedValidationAction
     */
    private void ensureMutualExclusivity(
            ValidationAction selectedValidationAction) {
        if (selectedValidationAction.getState() != ValidationAction.State.Off) {
            for (ValidationAction exclusiveValAction : selectedValidationAction
                    .getExclusiveValidations()) {
                getInstance().getCustomizedValidations().put(
                        exclusiveValAction.getId().name(),
                        ValidationAction.State.Off.name());
                getValidations().get(exclusiveValAction.getId()).setState(
                        ValidationAction.State.Off);
            }
        }
    }

    /**
     * Use FlashScopeBean to store message in page. Multiple ajax requests for
     * re-rendering statistics after updating will clear FacesMessages.
     * 
     * @param severity
     * @param message
     */
    private void addMessage(StatusMessage.Severity severity, String message) {
        StatusMessage statusMessage =
                new StatusMessage(severity, null, null, message, null);
        statusMessage.interpolate();

        if (flashScope == null) {
            initFlashScope();
        }
        flashScope.setAttribute("message", statusMessage);
    }

    private void initFlashScope() {
        flashScope =
                (FlashScopeBean) Component.getInstance(FlashScopeBean.class);
    }

    private void clearMessage() {
        if (flashScope == null) {
            initFlashScope();
        }
        flashScope.getAndClearAttribute("message");
    }

    public boolean isProjectActive() {
        return getInstance().getProject().getStatus() == EntityStatus.ACTIVE;
    }

    private void updateOverrideLocales() {
        if (iterationOverrideLocales != null) {
            getInstance().setOverrideLocales(iterationOverrideLocales);
            if (!iterationOverrideLocales) {
                getInstance().getCustomizedLocales().clear();
            } else if (iterationCustomizedItems != null) {
                Set<HLocale> locale =
                        localeServiceImpl
                                .convertCustomizedLocale(iterationCustomizedItems);
                getInstance().getCustomizedLocales().clear();
                getInstance().getCustomizedLocales().addAll(locale);
            }
        }
    }
}