dictmanageaction.java

利用STRUTS2+SPRING+HIBERNATE/IBATIS建立的基本开发框架

/**
 * 
 */
package com.sunwah.baseapp.system.action;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.struts2.interceptor.validation.SkipValidation;

import com.sunwah.baseapp.action.QueryManageAction;
import com.sunwah.baseapp.common.ActionConstants;
import com.sunwah.baseapp.common.Constants;
import com.sunwah.baseapp.common.DictionaryConstants;
import com.sunwah.baseapp.common.SqlConstants;
import com.sunwah.baseapp.system.criteria.DictQueryCriteria;
import com.sunwah.baseapp.system.model.DictionaryData;
import com.sunwah.baseapp.system.model.DictionaryType;
import com.sunwah.baseapp.system.service.DictionaryManager;
import com.sunwah.baseapp.system.service.DictionaryManagerStatusCodes;
import com.sunwah.baseapp.system.vo.UserVO;

/**
 * 字典配置Action类
 * 
 * @author MARK
 * 
 */
public class DictManageAction extends QueryManageAction {

	/**
	 * 
	 */
	private static final long serialVersionUID = -5755791791236602589L;

	private DictQueryCriteria queryCriteria;

	private DictionaryManager dictionaryManager;

	private DictionaryType dictType;

	private Long dictTypeId;

	private List<DictionaryData> dictDatas;

	private List<DictionaryData> dictDataList;

	@SkipValidation
	public String findDicts() {
		super.query(SqlConstants.GET_DICTS, SqlConstants.GET_DICT_COUNT,
				queryCriteria);
		super.check(ActionConstants.DICT_MANAGE_FIND_DICTS,
				ActionConstants.DICT_MANAGE_VIEW_DICT,
				ActionConstants.DICT_MANAGE_ADD_DICT,
				ActionConstants.DICT_MANAGE_EDIT_DICT,
				ActionConstants.DICT_MANAGE_DELETE_DICT);
		return SUCCESS;
	}

	@SkipValidation
	public String findDict() {
		dictType = this.dictionaryManager.findDictType(dictTypeId);
		if (dictType != null) {
			return SUCCESS;
		} else {
			this.addActionError(getText("data.not.exist"));
			return ERROR;
		}
	}

	@SkipValidation
	public String toCreateDict() {
		dictType = new DictionaryType();
		dictType.setState(DictionaryConstants.STATE_ENABLED);
		return SUCCESS;
	}

	public String createDict() {
		UserVO user = (UserVO) getSession().get(Constants.SESSION_USER);
		dictType.setCreateDate(new Date());
		dictType.setCreateUserId(user.getUserId());
		dictType.setModifyUserId(user.getUserId());
		dictType.setModifyDate(new Date());
		int statusCode = this.dictionaryManager.createDict(dictType, dictDatas);
		if (statusCode == DictionaryManagerStatusCodes.DICT_TYPE_NAME_EXIST) {
			super.addActionError(getText("dict.dictTypeName.existed"));
			return INPUT;
		}
		if (statusCode == DictionaryManagerStatusCodes.DICT_TYPE_CODE_EXIST) {
			super.addActionError(getText("dict.dictTypeCode.existed"));
			return INPUT;
		}
		return SUCCESS;
	}

	@SkipValidation
	public String deleteDict() {
		this.dictionaryManager.deleteDict(dictTypeId);
		return SUCCESS;
	}

	@SkipValidation
	public String toUpdateDict() {
		dictType = this.dictionaryManager.findDictType(dictTypeId);
		if (dictType == null) {
			this.addActionError(getText("data.not.exist"));
			return ERROR;
		}
		if (dictType.getDictionaryDatas() != null) {
			dictDataList = new ArrayList<DictionaryData>();
			dictDataList.addAll(dictType.getDictionaryDatas());
		}
		return SUCCESS;
	}

	public String updateDict() {
		UserVO user = (UserVO) getSession().get(Constants.SESSION_USER);
		dictType.setModifyUserId(user.getUserId());
		dictType.setModifyDate(new Date());
		int statusCode = this.dictionaryManager.updateDict(dictType, dictDatas);
		if (statusCode == DictionaryManagerStatusCodes.DICT_TYPE_NAME_EXIST) {
			super.addActionError(getText("dict.dictTypeName.existed"));
			return INPUT;
		}
		if (statusCode == DictionaryManagerStatusCodes.DICT_TYPE_CODE_EXIST) {
			super.addActionError(getText("dict.dictTypeCode.existed"));
			return INPUT;
		}
		// if (statusCode == DictionaryManagerStatusCodes.DICT_DATA_CODE_EXIST)
		// {
		// super.addActionError(getText("dict.dictDataCode.existed"));
		// return INPUT;
		// }
		// if (statusCode == DictionaryManagerStatusCodes.DICT_DATA_NAME_EXIST)
		// {
		// super.addActionError(getText("dict.dictDataName.existed"));
		// return INPUT;
		// }
		return SUCCESS;
	}

	@Override
	public void validate() {
		if ((super.getFieldErrors().size() > 0)
				|| (super.getActionErrors().size() > 0)) {
			dictDataList = new ArrayList<DictionaryData>();
			if (dictDatas != null)
				dictDataList.addAll(dictDatas);
		}
		super.validate();
	}

	public DictQueryCriteria getQueryCriteria() {
		return queryCriteria;
	}

	public void setQueryCriteria(DictQueryCriteria queryCriteria) {
		this.queryCriteria = queryCriteria;
	}

	public void setDictionaryManager(DictionaryManager dictionaryManager) {
		this.dictionaryManager = dictionaryManager;
	}

	public DictionaryType getDictType() {
		return dictType;
	}

	public void setDictType(DictionaryType dictType) {
		this.dictType = dictType;
	}

	public Long getDictTypeId() {
		return dictTypeId;
	}

	public void setDictTypeId(Long dictTypeId) {
		this.dictTypeId = dictTypeId;
	}

	public List<DictionaryData> getDictDatas() {
		return dictDatas;
	}

	public void setDictDatas(List<DictionaryData> dictDatas) {
		this.dictDatas = dictDatas;
	}

	public List<DictionaryData> getDictDataList() {
		return dictDataList;
	}

	public void setDictDataList(List<DictionaryData> dictDataList) {
		this.dictDataList = dictDataList;
	}

}