FormServiceImpl.java

package org.hsweb.web.service.impl.form;

import com.alibaba.fastjson.JSON;
import org.hsweb.commons.StringUtils;
import org.hsweb.ezorm.rdb.meta.RDBTableMetaData;
import org.hsweb.web.bean.common.InsertParam;
import org.hsweb.web.bean.common.QueryParam;
import org.hsweb.web.bean.po.form.Form;
import org.hsweb.web.bean.po.form.Form.Property;
import org.hsweb.web.bean.po.history.History;
import org.hsweb.web.core.utils.RandomUtil;
import org.hsweb.web.dao.form.FormMapper;
import org.hsweb.web.service.form.DynamicFormService;
import org.hsweb.web.service.form.FormParser;
import org.hsweb.web.service.form.FormService;
import org.hsweb.web.service.history.HistoryService;
import org.hsweb.web.service.impl.AbstractServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

/**
 * 自定义表单服务类
 * Created by generator
 */
@Service("formService")
public class FormServiceImpl extends AbstractServiceImpl<Form, String> implements FormService {

    private static final String CACHE_KEY = "form";

    @Autowired(required = false)
    protected FormParser formParser = new DefaultFormParser();

    @Resource
    protected FormMapper formMapper;

    @Resource
    protected HistoryService historyService;

    @Override
    protected FormMapper getMapper() {
        return formMapper;
    }

    @Resource
    protected DynamicFormService dynamicFormService;

    @Override
//    @Cacheable(value = CACHE_KEY, key = "#id")
    public Form selectByPk(String id) {
        return super.selectByPk(id);
    }

    @Override
    public String createNewVersion(String oldVersionId) {
        Form old = this.selectByPk(oldVersionId);
        assertNotNull(old, "表单不存在!");
        old.setId(RandomUtil.randomChar());
        old.setVersion(old.getVersion() + 1);
        old.setCreateDate(new Date());
        old.setUpdateDate(null);
        old.setRevision(1);
        old.setRelease(0);
        old.setUsing(false);
        getMapper().insert(InsertParam.build(old));
        return old.getId();
    }

    @Override
    public String insert(Form data) {
        List<Form> old = this.select(QueryParam.build().where("name", data.getName()));
        Assert.isTrue(old.isEmpty(), "表单 [" + data.getName() + "] 已存在!");
        data.setCreateDate(new Date());
        data.setVersion(1);
        if (StringUtils.isNullOrEmpty(data.getId()))
            data.setId(RandomUtil.randomChar());
        super.insert(data);
        return data.getId();
    }

    @Override
    @Caching(
            evict = {
                    @CacheEvict(value = {CACHE_KEY}, key = "#data.id"),
                    @CacheEvict(value = {CACHE_KEY}, key = "#data.name+':'+#data.version")
            }
    )
    public int update(Form data) {
        Form old = this.selectByPk(data.getId());
        assertNotNull(old, "表单不存在!");
        data.setUpdateDate(new Date());
        data.setVersion(old.getVersion());
        data.setRevision(old.getRevision() + 1);
        return createUpdate(data).excludes(Property.using, Property.createDate, Property.release, Property.version)
                .fromBean().where(Property.id).exec();
    }

    @Override
    @CacheEvict(value = CACHE_KEY, key = "#id")
    public int delete(String id) {
        Form old = this.selectByPk(id);
        assertNotNull(old, "表单不存在!");
        Assert.isTrue(!old.isUsing(), "表单正在使用，无法删除!");
        return super.delete(id);
    }

    @Override
    @Transactional(readOnly = true)
    public List<Form> selectLatestList(QueryParam param) {
        return formMapper.selectLatestList(param);
    }

    @Override
    @Transactional(readOnly = true)
    public int countLatestList(QueryParam param) {
        return formMapper.countLatestList(param);
    }

    @Override
    @Cacheable(value = CACHE_KEY, key = "#name+':'+#version")
    public Form selectByVersion(String name, int version) {
        List<Form> formList = this.createQuery()
                .where(Property.name, name).and(Property.version, version)
                .list(formMapper::selectLatestList);
        return formList.size() > 0 ? formList.get(0) : null;
    }

    @Override
    public Form selectLatest(String name) {
        List<Form> formList = this.createQuery()
                .where(Property.name, name)
                .orderByAsc(Property.version)
                .list(formMapper::selectLatestList);
        return formList.size() > 0 ? formList.get(0) : null;
    }

    @Override
    @Caching(evict = {
            @CacheEvict(value = {CACHE_KEY + ".deploy"}, allEntries = true),
            @CacheEvict(value = {CACHE_KEY}, allEntries = true)
    })
    public void tryDeployAll() {
        createQuery().where(Form.Property.using, 1).listNoPaging().forEach(form -> {
            try {
                Form deployed = selectDeployed(form.getName());
                if (null != deployed) {
                    RDBTableMetaData metaData = dynamicFormService.parseMeta(deployed);
                    dynamicFormService.getDefaultDatabase().reloadTable(metaData);
                } else {
                    dynamicFormService.deploy(form);
                }
            } catch (Exception e) {
                logger.error("部署{}:({})失败", form.getName(), form.getRemark(), e);
            }
        });
    }

    @Override
    @Transactional(rollbackFor = Throwable.class)
    @Caching(evict = {
            @CacheEvict(value = {CACHE_KEY + ".deploy"}, key = "'deploy.'+target.selectByPk(#formId).getName()+'.html'"),
            @CacheEvict(value = {CACHE_KEY + ".deploy"}, key = "'deploy.'+target.selectByPk(#formId).getName()"),
            @CacheEvict(value = {CACHE_KEY}, key = "'using.'+target.selectByPk(#formId).getName()"),
            @CacheEvict(value = {CACHE_KEY}, key = "'deploy.'+target.selectByPk(#formId).getName()+'.version'")
    })
    public void deploy(String formId) throws SQLException {
        Form old = this.selectByPk(formId);
        assertNotNull(old, "表单不存在");
        //先卸载正在使用的表单
        Form using = selectUsing(old.getName());
        if (using != null) {
            this.unDeploy(using.getId());
        }
        //开始发布
        old.setUsing(true);
        dynamicFormService.deploy(old);
        old.setRelease(old.getRevision());//发布修订版本
        createUpdate(old).includes(Property.using, Property.release).where(Property.id, old.getId()).exec();
        //加入发布历史记录
        History history = History.newInstance("form.deploy." + old.getName());
        history.setPrimaryKeyName("id");
        history.setPrimaryKeyValue(old.getId());
        history.setChangeBefore("{}");
        history.setChangeAfter(JSON.toJSONString(old));
        historyService.insert(history);
    }

    @Override
    @Transactional(rollbackFor = Throwable.class)
    @Caching(evict = {
            @CacheEvict(value = {CACHE_KEY + ".deploy"}, key = "'deploy.'+target.selectByPk(#formId).getName()+'.html'"),
            @CacheEvict(value = {CACHE_KEY + ".deploy"}, key = "'deploy.'+target.selectByPk(#formId).getName()"),
            @CacheEvict(value = {CACHE_KEY}, key = "'using.'+target.selectByPk(#formId).getName()"),
            @CacheEvict(value = {CACHE_KEY}, key = "'deploy.'+target.selectByPk(#formId).getName()+'.version'")
    })
    public void unDeploy(String formId) {
        Form old = this.selectByPk(formId);
        assertNotNull(old, "表单不存在");
        dynamicFormService.unDeploy(old);
        old.setUsing(false);
        createUpdate(old).includes(Property.using).where(Property.id, old.getId()).exec();
    }

    @Override
    @Cacheable(value = CACHE_KEY + ".deploy", key = "'deploy.'+#name+'.html'")
    public String createDeployHtml(String name) {
        History history = historyService.selectLastHistoryByType("form.deploy." + name);
        assertNotNull(history, "表单不存在");
        return formParser.parseHtml(JSON.parseObject(history.getChangeAfter(), Form.class));
    }

    @Override
    @Cacheable(value = CACHE_KEY + ".deploy", key = "'deploy.'+#name")
    public Form selectDeployed(String name) {
        Form using = selectUsing(name);
        assertNotNull(using, "表单不存在或未部署");
        History history = historyService.selectLastHistoryByType("form.deploy." + name);
        assertNotNull(history, "表单不存在或未部署");
        return JSON.parseObject(history.getChangeAfter(), Form.class);
    }

    @Override
    public String createViewHtml(String formId) {
        Form form = this.selectByPk(formId);
        assertNotNull(form, "表单不存在");
        return formParser.parseHtml(form);
    }

    @Override
    @Cacheable(value = CACHE_KEY, key = "'using.'+#name")
    public Form selectUsing(String name) {
        return createQuery().where(Property.using,1).and().is(Property.name,name).single();
    }

    @Override
    @Cacheable(value = CACHE_KEY, key = "'deploy.'+#name+'.version'")
    public int selectDeployedVersion(String name) {
        return selectDeployed(name).getRelease();
    }
}