struts2注解

package com.launch.yqyc.action.admin;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.InterceptorRef;
import org.apache.struts2.convention.annotation.Result;
import org.springframework.beans.factory.annotation.Autowired;

import com.launch.core.crypto.MD5Encoder;
import com.launch.core.util.DateUtil;
import com.launch.core.util.PagingHelper;
import com.launch.core.util.Struts2Util;
import com.launch.yqyc.Constants;
import com.launch.yqyc.action.BaseAction;
import com.launch.yqyc.common.UserCounterListener;
import com.launch.yqyc.model.AlgorithmFunc;
import com.launch.yqyc.model.DtcAlert;
import com.launch.yqyc.model.FlashFile;
import com.launch.yqyc.model.Menu;
import com.launch.yqyc.model.Role;
import com.launch.yqyc.model.SysUser;
import com.launch.yqyc.model.VehicleType;
import com.launch.yqyc.service.AlgorithmFuncManager;
import com.launch.yqyc.service.DtcAlertManager;
import com.launch.yqyc.service.FlashFileManager;
import com.launch.yqyc.service.SysUserManager;
import com.launch.yqyc.service.VehicleTypeManager;
import com.launch.yqyc.util.MenuComparator;
import com.launch.yqyc.util.YqycUtils;
import com.launch.yqyc.vo.OnLineUser;

/**
* <p>SysUserAction</p>
*
* <p>实现用户管理界面上的CRUD、登录、退出等操作</p>
*
* @author chenming
* @since 1.0
* @version $Id: SysUserAction.java 1.0 Aug 6, 2012 $
*/
public class SysUserAction extends BaseAction
{
    private static final long serialVersionUID = 48L;

    /**
     * save(), update()..等操作执行的action redirectionUrl = LIST_ACTION
     */
    public static final String LIST_ACTION = "sys_user!list.action";

    /**
     * 4s用户
     */
    public static final String LIST_4S = "list4s";

    /**
     * 返回4s用户列表
     */
    public static final String LIST_4S_ACTION = "sys_user!list4s.action";
   
    /**
     * 专家/4s用户远程协助
     */
    public static final String VIEW_REMOTE_ASSIST = "remote_assist_view";

    /**
     * 技术员用户
     */
    public static final String lIST_TECHNICIAN = "list_technician";

    /**
     * 4s用户禁用列表
     */
    public static final String LIMIT_4S_ACTION = "sys_user!limit4slist.action";
   
    /**
     * 浏览4s用户禁用列表
     */
    public static final String LIMIT_4S_LIST = "limit4slist";
   
    /**
     * 普通用户维护个人资料
     */
    public static final String MAINTAIN_VIEW_ACTION = "sys_user!maintainview.action";

    // serialNo, diskSerial, macAddr
    private String serialNo;
   
    private String diskSerial;
   
    private String macAddr;
   
    @Autowired
    private SysUserManager sysUserManager;

    @Autowired
    private AlgorithmFuncManager algorithmFuncManager;

    /**
     * 算法功能对象
     */
    private AlgorithmFunc algorithmFunc;

    @Autowired
    private FlashFileManager flashFileManager;
   
    @Autowired
    private DtcAlertManager dtcAlertManager;
   
    @Autowired
    private VehicleTypeManager vehicleTypeManager;
   
    /**
     * 刷写文件对象
     */
    private FlashFile flashFile;

    /**
     * 用户名
     */
    private String userName;
   
    /**
     * 用户类型
     */
    private Integer userType;
   
    /**
     * 用户密码
     */
    private String userPassword;

    /**
     * 旧用户名，用于编辑判断唯一性
     */
    private String oldUserName;

    /**
     * 用户ID
     */
    private String userId;

    /**
     * 获取页面上所有的记录ID
     */
    private String[] pageIds;

    /**
     * 确认密码，用于校验两次输入密码是否一致
     */
    private String reUserPassword;

    /**
     * 用户对象
     */
    private SysUser sysUser;

    /**
     * 首页转来查询未审核用户记录数
     */
    private int userStatus = -1;

    /**
     * 进入登录页面
     * @return
     */
    @Action(value = "go_login", interceptorRefs = { @InterceptorRef(value = "yqycCoreStack") }, results = { @Result(name = "success", location = "/WEB-INF/jsp/admin/login.jsp") })
    public String goLogin()
    {
        return SUCCESS;
    }

    /**
     * 登录操作
     * @return
     */
    @SuppressWarnings("unchecked")
    @Action(value = "login", interceptorRefs = { @InterceptorRef("jCaptchaValidationIntercepter"), @InterceptorRef("logInterceptor"), @InterceptorRef(value = "yqycCoreStack") }, results = { @Result(name = "success", type = "redirect", location = "/admin/index.action") })
    public String login()
    {
        // 根据登录用户的用户名和密码检查是否存在对应的用户对象
        sysUser = sysUserManager.login(userName, userPassword);
        if (sysUser == null)
        {
            addActionError(getText("common.userauth.error"));
            return ERROR;
        }
       
       /*
        * List<OnLineUser> onLineUsers = (List<OnLineUser>) Struts2Util.getServletContext().getAttribute(UserCounterListener.USERS_KEY);
        if (onLineUsers.contains(onLineUser))
        {
            addActionError("用户["+sysUser.getUserName()+"]已经登录");
            //Struts2Util.removeSession(Constants.SESSION_USER);
            return ERROR;
        }*/
        //初始化在线用户信息;
        Date loginTime = DateUtil.getCurrentDate();
        OnLineUser onLineUser = new OnLineUser();
        onLineUser.setId(sysUser.getId());
        onLineUser.setLoginIp(YqycUtils.getRemortIP(Struts2Util.getRequest()));
        onLineUser.setLoginTime(loginTime);
        onLineUser.setUserName(sysUser.getUserName());
        onLineUser.setUserType(sysUser.getUserType());
        Struts2Util.setSession(UserCounterListener.EVENT_KEY, onLineUser);
       
        // 保存登录用户的上次登录时间到session中
        Struts2Util.setSession(Constants.SESSION_LAST_LOGIN_TIME, sysUser.getLastLoginTime());
       
        // 保存登录用户的用户对象到session中
        setSessionUser(sysUser);
       
        // 保存登录用户的IP地址
        Struts2Util.setSession(Constants.SESSION_LOGIN_IP, YqycUtils.getRemortIP(Struts2Util.getRequest()));
      
        // 获取登录用户的菜单权限
        Map<String, Menu> menuMap = new HashMap<String, Menu>();
        Iterator roleIt = sysUser.getRoles().iterator();
        while (roleIt.hasNext())
        {
            Role role = (Role) roleIt.next();
            Iterator menuIt = role.getMenus().iterator();
            while (menuIt.hasNext())
            {
                Menu menu = (Menu) menuIt.next();
                menuMap.put(menu.getId(), menu);
            }
        }
        List<Menu> menuList = new ArrayList<Menu>();
        List<Entry<String, Menu>> menuEntryList = new ArrayList<Entry<String, Menu>>(menuMap.entrySet());
        for (Entry<String, Menu> mEntry : menuEntryList)
        {
            menuList.add(mEntry.getValue());
        }
       
        // 将登录用户的菜单权限按索引排序
        MenuComparator menuComparator = new MenuComparator();
        Collections.sort(menuList, menuComparator);
       
        // 保存登录用户的菜单权限List对象到session中
        Struts2Util.setSession(Constants.SESSION_MENU_LIST, menuList);
       
        // 更新登录用户的'上次登录时间'
        sysUser.setLastLoginTime(loginTime);
        sysUserManager.update(sysUser);
       
        // 写入操作日志记录
        operateContent = sysUser.getUserName() + "登录";
        operateType = Constants.OPERATE_TYPE_LOGIN;
        return SUCCESS;
    }
   
    @Action(value = "go_shop_login", interceptorRefs = { @InterceptorRef(value = "yqycCoreStack") }, results = { @Result(name = "success", location = "/WEB-INF/jsp/admin/shop_login.jsp") })
    public String goShopLogin()
    {
        return SUCCESS;
    }
   
    /**
     * 4s店登录
     * @return
     */
    @SuppressWarnings("unchecked")
    @Action(
        value = "shop_login",
        interceptorRefs = {@InterceptorRef("logInterceptor"),@InterceptorRef(value = "yqycCoreStack") },
        results = { @Result(name = "success", type = "redirect", location = "/admin/index.action"), @Result(name = "error", type="freemarker",location="/template/shopLoginError.ftl")}
        )
       
    public String shopLogin()
    {
        // 根据登录用户的用户名和密码检查是否存在对应的用户对象
        sysUser = sysUserManager.getUser(serialNo, diskSerial, macAddr);
        if (sysUser == null)
        {
            return ERROR;
        }
        //初始化在线用户信息;
        Date loginTime = DateUtil.getCurrentDate();
        OnLineUser onLineUser = new OnLineUser();
        onLineUser.setId(sysUser.getId());
        onLineUser.setLoginIp(YqycUtils.getRemortIP(Struts2Util.getRequest()));
        onLineUser.setLoginTime(loginTime);
        onLineUser.setUserName(sysUser.getRepairSite().getShopName());
        onLineUser.setUserType(sysUser.getUserType());
       
        Struts2Util.setSession(UserCounterListener.EVENT_KEY, onLineUser);
       
        // 保存登录用户的上次登录时间到session中
        Struts2Util.setSession(Constants.SESSION_LAST_LOGIN_TIME, sysUser.getLastLoginTime());

        // 保存登录用户的用户对象到session中
        setSessionUser(sysUser);
       
        // 保存登录用户的IP地址
        Struts2Util.setSession(Constants.SESSION_LOGIN_IP, YqycUtils.getRemortIP(Struts2Util.getRequest()));
      
        // 获取登录用户的菜单权限
        Map<String, Menu> menuMap = new HashMap<String, Menu>();
        Iterator roleIt = sysUser.getRoles().iterator();
        while (roleIt.hasNext())
        {
            Role role = (Role) roleIt.next();
            Iterator menuIt = role.getMenus().iterator();
            while (menuIt.hasNext())
            {
                Menu menu = (Menu) menuIt.next();
                menuMap.put(menu.getId(), menu);
            }
        }
        List<Menu> menuList = new ArrayList<Menu>();
        List<Entry<String, Menu>> menuEntryList = new ArrayList<Entry<String, Menu>>(menuMap.entrySet());
        for (Entry<String, Menu> mEntry : menuEntryList)
        {
            menuList.add(mEntry.getValue());
        }
       
        // 将登录用户的菜单权限按索引排序
        MenuComparator menuComparator = new MenuComparator();
        Collections.sort(menuList, menuComparator);
       
        // 保存登录用户的菜单权限List对象到session中
        Struts2Util.setSession(Constants.SESSION_MENU_LIST, menuList);
       
        // 更新登录用户的'上次登录时间'
        sysUser.setLastLoginTime(loginTime);
        sysUserManager.update(sysUser);
       
        // 写入操作日志记录
        operateContent = sysUser.getUserName() + "登录";
        operateType = Constants.OPERATE_TYPE_LOGIN;
        return SUCCESS;
    }
    /**
     * 退出
     * @return
     */
    @Action(value = "logout", interceptorRefs = { @InterceptorRef("logInterceptor"), @InterceptorRef(value = "yqycCoreStack") }, results = { @Result(name = "success", type = "redirect", location = "/admin/index.action") })
    public String logout()
    {
        operateContent = Struts2Util.getSession().get(Constants.SESSION_USER_NAME) + "退出";
        operateType = Constants.OPERATE_TYPE_LOGOUT;
        Struts2Util.getSession().remove(Constants.SESSION_USER);
        Struts2Util.getSession().remove(Constants.SESSION_USER_NAME);
        Struts2Util.getSession().remove(Constants.SESSION_LOGIN_IP);
        Struts2Util.getSession().remove(UserCounterListener.EVENT_KEY);
        Struts2Util.getSession().remove(Constants.SESSION_MENU_LIST);
        return SUCCESS;
    }

    /**
     * 显示菜单
     * @return
     */
    @Action(value = "page_menu", results = { @Result(location = "/page/pagemenu.jsp") })
    public String pageMenu()
    {
        return SUCCESS;
    }

    /**
     * 显示首页信息 (不包括)
     * @return
     */
    @Action(value = "page_index", results = { @Result(location = "/page/pageindex.jsp") })
    public String pageIndex()
    {
        SysUser sysUser = getSessionUser();
        Integer userType = sysUser.getUserType();
        if ((Constants.USER_TYPE_EXPERT != userType) || (Constants.USER_TYPE_SHOP == userType))
        {
            // 4s用户--未审核数
            int unAuditedUserCount = sysUserManager.getTotalCount(Constants.USER_TYPE_SHOP, Constants.USER_STATUS_UNAUDITED);
            Struts2Util.setSession(Constants.UNAUDITED_USER_COUNT, unAuditedUserCount);
            // 获取未审核刷写文件目录数
            FlashFile flashFile = new FlashFile();
            flashFile.setStatus(Constants.FLASH_FILE_STATUS_UNAUDITED);
            long unAuditedFlashFileCount = flashFileManager.getTotalCount(flashFile);
            Struts2Util.setSession(Constants.UNAUDITED_FLASH_FILE_COUNT, unAuditedFlashFileCount);
            //获取用户预警记录数：
            DtcAlert dtcAlert = new DtcAlert();
            dtcAlert.setSysUser(getSessionUser());
            dtcAlert.setStatus(Constants.YES);
            long userDtcAlertCount = dtcAlertManager.getTotalCount(dtcAlert);
            Struts2Util.setSession(Constants.USER_DTC_ALERT_COUNT, userDtcAlertCount);
        }
        return SUCCESS;
    }

    /**
     * 进入新增页面
     * @return
     */
    public String add()
    {
        return ADD;
    }

    /**
     * 保存普通用户
     * @return
     */
    @Action("save_user")
    public String save()
    {
        // 默认用户状态为'已审核'
        sysUser.setStatus(Constants.USER_STATUS_APPROVED);
        // 默认当前时间为'创建时间'
        sysUser.setCreateTime(new Date());
        if (sysUser.getUserType().intValue() == Constants.USER_TYPE_EXPERT)
        {
            sysUser.setVideoSystemId(sysUserManager.getVideoSystemId());
        }
       
        // MD5加密
        sysUser.setUserPassword(MD5Encoder.getMD5(sysUser.getUserPassword()));
       
        sysUserManager.save(sysUser);
        operateContent = "添加用户[id=" + sysUser.getId() + "]";
        operateType = Constants.OPERATE_TYPE_SAVE;
        redirectionUrl = LIST_ACTION;
        return SUCCESS;
    }

    /**
     * 逻辑删除用户，但保留与这些用户相关的所有信息 该用户已不再使用，但改变用户状态为'已删除'，保存该用户记录，以便日后备查
     * @return
     */
    public String delete()
    {
        sysUserManager.deleteUser(ids);
        operateContent = "批量删除多个用户[ids=" + YqycUtils.arrayToSqlIn(ids) + "]";
        operateType = Constants.OPERATE_TYPE_DELETE;
        redirectionUrl = LIST_ACTION;
        return SUCCESS;
    }
   
    /**
     * 物理删除选中的4S用户
     * @return
     */
    public String delete4s()
    {
        sysUserManager.delete(ids);
        operateContent = "批量删除多个4S用户[ids=" + YqycUtils.arrayToSqlIn(ids) + "]";
        operateType = Constants.OPERATE_TYPE_DELETE;
        redirectionUrl = LIST_4S_ACTION;
        return SUCCESS;
    }

    /**
     * 进入编辑页面
     */
    public String edit()
    {
        sysUser = sysUserManager.get(id);
        return EDIT;
    }

    /**
     * 更新普通用户
     * @return
     */
    @Action("update_user")
    public String update()
    {
        SysUser su = sysUserManager.get(id);
        su.setUserName(sysUser.getUserName());
        if (StringUtils.isNotBlank(sysUser.getUserPassword()))
        {
            su.setUserPassword(MD5Encoder.getMD5(sysUser.getUserPassword()));
        }
        su.setUserType(sysUser.getUserType());
        su.setEmail(sysUser.getEmail());
        su.setRemarks(sysUser.getRemarks());
        sysUserManager.update(su);
        operateContent = "更新用户[id=" + id + "]";
        operateType = Constants.OPERATE_TYPE_UPDATE;
        redirectionUrl = LIST_ACTION;
        return SUCCESS;
    }
   
    /**
     * 进入维护普通用户个人资料页面
     * @return
     */
    public String maintainview()
    {
        sysUser = (SysUser)Struts2Util.getSession(Constants.SESSION_USER);
        return "maintain";
    }
   
    /**
     * 维护普通用户个人资料
     * @return
     */
    @Action(value = "maintain_user")
    public String maintain()
    {
        SysUser su = sysUserManager.get(sysUser.getId());
        su.setUserName(sysUser.getUserName());
        if (StringUtils.isNotBlank(sysUser.getUserPassword()))
        {
            su.setUserPassword(MD5Encoder.getMD5(sysUser.getUserPassword()));
        }
        su.setEmail(sysUser.getEmail());
        su.setRemarks(sysUser.getRemarks());
       
        sysUserManager.update(su);
       
        // 保存登录用户的用户对象到session中
        setSessionUser(sysUser);
        redirectionUrl = "sys_user!maintainview.action";
        operateContent = "维护用户个人资料[id=" + sysUser.getId() + "]";
        operateType = Constants.OPERATE_TYPE_UPDATE;
        return SUCCESS;
    }

    /**
     * 验证用户名是否存在
     * @return
     */
    @Action(value = "check_user_name_exists", results = { @Result(name = "success", type = "json", params = { "root", RESULT }) })
    public String checkUserNameExists()
    {
        boolean flag = sysUserManager.isExists("userName", sysUser.getUserName(), oldUserName);
        Struts2Util.setObjToValueStack(RESULT, !flag);
        return SUCCESS;
    }

    /**
     * 浏览用户信息
     * @return
     */
    public String view()
    {
        if (StringUtils.isBlank(id))
        {
            id = ((SysUser) Struts2Util.getSession().get(Constants.SESSION_USER)).getId();
        }
        sysUser = sysUserManager.get(id);
        return VIEW;
    }

    /**
     * 进入4s用户审核页面
     */
    public String audit()
    {
        sysUser = sysUserManager.get(id);
        return AUDIT;
    }

    /**
     * 审核4s用户
     * @return
     */
    @Action("audit_user")
    public String auditUser()
    {
        SysUser su = sysUserManager.get(id);
        // 修改审核人
        su.setAuditUser((String) Struts2Util.getSession().get(Constants.SESSION_USER_NAME));
        sysUserManager.auditUser(su);
        operateContent = "审核4s用户[id=" + id + "]";
        operateType = Constants.OPERATE_TYPE_AUDIT;
        redirectionUrl = LIST_4S_ACTION;
        return SUCCESS;
    }
   
    /**
     * 远程协助--视频+桌面
     */
    @Action("remote_assist")
    public String remoteAssist()
    {
        return VIEW_REMOTE_ASSIST;
    }

    /**
     * 浏览普通用户列表
     */
    public String list()
    {
        if (sysUser == null)
        {
            sysUser = new SysUser();
            sysUser.setUserType(Constants.USER_TYPE_COMMON);
        }
        setDefaultPageOrder(page, "createTime", PagingHelper.DESC);
        page = sysUserManager.findPage(page, sysUser);
        return LIST;
    }

    /**
     * 浏览4s用户列表
     */
    public String list4s()
    {
        if (sysUser == null)
        {
            sysUser = new SysUser();
            sysUser.setUserType(Constants.USER_TYPE_SHOP);
            if (userStatus != -1)
            {
                sysUser.setStatus(Constants.USER_STATUS_UNAUDITED);
            }
        }
        setDefaultPageOrder(page, "createTime", PagingHelper.DESC);
        page = sysUserManager.findPage(page, sysUser);
        return LIST_4S;
    }

    /**
     * 在线用户列表
     * 默认按登录时间倒序
     * @return
     */
    @SuppressWarnings("unchecked")
    public String listOnlineUser()
    {
        List<OnLineUser> onLineUsersx = (List<OnLineUser>)Struts2Util.getServletContext().getAttribute(UserCounterListener.USERS_KEY);
        List<OnLineUser> onLineUsers = new LinkedList<OnLineUser>();
        CollectionUtils.addAll(onLineUsers, onLineUsersx.iterator());
        if (StringUtils.isNotBlank(userName) && userType != null)
        {
            for (Iterator<OnLineUser> iterator = onLineUsers.iterator(); iterator.hasNext();)
            {
                OnLineUser onLineUser = iterator.next();
                if (!(StringUtils.equals(onLineUser.getUserName(), userName) && (onLineUser.getUserType().equals(userType))))
                {
                    iterator.remove();
                }
            }
        }
        else if (StringUtils.isNotBlank(userName) && userType == null)
        {
            for (Iterator<OnLineUser> iterator = onLineUsers.iterator(); iterator.hasNext();)
            {
                if (!StringUtils.equals(iterator.next().getUserName(), userName))
                {
                    iterator.remove();
                }
            }
        }
        else if (StringUtils.isBlank(userName) && userType != null)
        {
            for (Iterator<OnLineUser> iterator = onLineUsers.iterator(); iterator.hasNext();)
            {
                if (!(iterator.next().getUserType().equals(userType)))
                {
                    iterator.remove();
                }
            }
        }
        Collections.sort(onLineUsers, new Comparator<OnLineUser>(){

            @Override
            public int compare(OnLineUser o1, OnLineUser o2)
            {
                return -(o1.getLoginTime().compareTo(o2.getLoginTime()));
            }
           
        });
        page.setSize(onLineUsers.size());
        int total = page.getSize();
        int pageNo = page.getPageNo();
        int pageSize = page.getPageSize();
        int offset = (pageNo - 1) * pageSize;
        int leftSize = total - pageSize*(pageNo-1);
        if (page.getSize() > 0 && leftSize > pageSize )
        {
            onLineUsers = onLineUsers.subList(offset, offset+pageSize);
        }
        else if (page.getSize() > 0 && leftSize <= pageSize )
        {
            onLineUsers = onLineUsers.subList(offset, leftSize);
        }
       
        page.setDataList(onLineUsers);
        page.setOrderBy("loginTime");
        page.setOrder(PagingHelper.DESC);
        return "listonlineuser";
    }
   
    /**
     * 剔除用户
     * @return
     */
    @SuppressWarnings("unchecked")
    public String evictOnlineUser()
    {
        ServletContext servletContext = Struts2Util.getServletContext();
        HashMap<String, HttpSession> sessionMap = (HashMap<String, HttpSession>) servletContext.getAttribute(UserCounterListener.SESSIONS_KEY);
        HttpSession session = sessionMap.get(id);
        if (session != null)
        {
            session.invalidate();
        }
        List<OnLineUser> onLineUsersx = (List<OnLineUser>)Struts2Util.getServletContext().getAttribute(UserCounterListener.USERS_KEY);
        List<OnLineUser> onLineUsers = new LinkedList<OnLineUser>();
        CollectionUtils.addAll(onLineUsers, onLineUsersx.iterator());
        Collections.sort(onLineUsers, new Comparator<OnLineUser>(){
            @Override
            public int compare(OnLineUser o1, OnLineUser o2)
            {
                return -(o1.getLoginTime().compareTo(o2.getLoginTime()));
            }
           
        });
        page.setSize(onLineUsers.size());
        int total = page.getSize();
        int pageNo = page.getPageNo();
        int pageSize = page.getPageSize();
        int offset = (pageNo - 1) * pageSize;
        int leftSize = total - pageSize*(pageNo-1);
        if (page.getSize() > 0 && leftSize > pageSize )
        {
            onLineUsers = onLineUsers.subList(offset, offset+pageSize);
        }
        else if (page.getSize() > 0 && leftSize <= pageSize )
        {
            onLineUsers = onLineUsers.subList(offset, leftSize);
        }
        page.setDataList(onLineUsers);
        redirectionUrl = "sys_user!listOnlineUser.action";
        return SUCCESS;
    }
    /**
     * 浏览技术员列表
     */
    public String listTechnician()
    {
        System.out.println("SysUserAction.listTechnician()"+sysUser);
        if (sysUser == null)
        {
            sysUser = new SysUser();
            sysUser.setUserType(Constants.USER_TYPE_TECHNICIAN);
            sysUser.setStatus(Constants.USER_STATUS_APPROVED);
        }
        setDefaultPageOrder(page, "createTime", PagingHelper.DESC);
        page = sysUserManager.findPage(page, sysUser);
        return lIST_TECHNICIAN;
    }

    /**
     * 浏览4s用户禁用列表
     */
    public String limit4slist()
    {
        System.out.println("SysUserAction.limit4slist()"+sysUser);
        if (sysUser == null)
        {
            sysUser = new SysUser();
            sysUser.setUserType(Constants.USER_TYPE_SHOP);
            sysUser.setStatus(Constants.USER_STATUS_APPROVED);
        }
        setDefaultPageOrder(page, "createTime", PagingHelper.DESC);
        page = sysUserManager.findPage(page, sysUser);
        return LIMIT_4S_LIST;
    }

    /**
     * 禁用刷写文件
     */
    @Action(value = "update_limit_flash_file")
    public String updateLimitFlashFile()
    {
        try
        {
            // 保存选择的算法到关联表中
            SysUser sysUser = sysUserManager.get(userId);
            Set<FlashFile> flashFiles = sysUser.getFlashFiles();
            Collection<String> checkedIds = new ArrayList<String>();
            CollectionUtils.addAll(checkedIds, ids);
            Collection<String> aPageIds = new ArrayList<String>();
            CollectionUtils.addAll(aPageIds, pageIds);
            YqycUtils.mergeByCheckedIds(flashFiles, checkedIds, aPageIds, FlashFile.class);
            sysUser.setFlashFiles(flashFiles);
            sysUserManager.update(sysUser);
            operateContent = "禁用刷写文件[id=" + StringUtils.join(aPageIds, ",") + "]";
            operateType = Constants.OPERATE_TYPE_UPDATE;
        }
        catch (Exception e)
        {
            addActionError("操作失败");
            return ERROR;
        }
        redirectionUrl = LIMIT_4S_ACTION;
        return SUCCESS;
    }

    /**
     * 刷写文件权限禁用
     */
    public String limitFlashFile()
    {
        // 获取用户算法禁用列表
        SysUser sysUser = sysUserManager.get(userId);
        List<String> selectIds = new ArrayList<String>();
        Set<FlashFile> flashFiles = sysUser.getFlashFiles();
        if (CollectionUtils.isNotEmpty(flashFiles))
        {
            for (FlashFile flashFile : flashFiles)
            {
                selectIds.add(flashFile.getId());
            }
        }
        List<VehicleType> vehicleTypes = vehicleTypeManager.getAll();
        Struts2Util.setObjToValueStack("vehicleTypes", vehicleTypes);
       
        Struts2Util.setObjToValueStack("selectIds", StringUtils.join(selectIds, ","));
        flashFileManager.findPage(page, flashFile);
        return "limitflashfile";
    }

    /**
     * 禁用算法
     */
    @Action(value = "update_limit_algorithm_func")
    public String updateLiminAlgorithmFunc()
    {
        try
        {
            // 保存选择的算法到关联表中
            SysUser sysUser = sysUserManager.get(userId);
            Set<AlgorithmFunc> algorithmFuncs = sysUser.getAlgorithmFuncs();
            Collection<String> checkedIds = new ArrayList<String>();
            CollectionUtils.addAll(checkedIds, ids);
            Collection<String> aPageIds = new ArrayList<String>();
            CollectionUtils.addAll(aPageIds, pageIds);
            YqycUtils.mergeByCheckedIds(algorithmFuncs, checkedIds, aPageIds, AlgorithmFunc.class);
            sysUser.setAlgorithmFuncs(algorithmFuncs);
            sysUserManager.update(sysUser);
            operateContent = "禁用算法[id=" + StringUtils.join(aPageIds, ",") + "]";
            operateType = Constants.OPERATE_TYPE_UPDATE;
        }
        catch (Exception e)
        {
            addActionError("操作失败");
            return ERROR;
        }
        redirectionUrl = LIMIT_4S_ACTION;
        return SUCCESS;
    }

    /**
     * 算法权限禁用
     */
    public String limitAlgorithmFunc()
    {
        // 获取用户算法禁用列表
        SysUser sysUser = sysUserManager.get(userId);
        List<String> selectIds = new ArrayList<String>();
        Set<AlgorithmFunc> algorithmFuncs = sysUser.getAlgorithmFuncs();
        if (CollectionUtils.isNotEmpty(algorithmFuncs))
        {
            for (AlgorithmFunc alg : algorithmFuncs)
            {
                selectIds.add(alg.getId());
            }
        }
        Struts2Util.setObjToValueStack("selectIds", StringUtils.join(selectIds, ","));
        setDefaultPageOrder(page, "functionName", PagingHelper.ASC);
        algorithmFuncManager.findPage(page, algorithmFunc);
        return "limitalgorithmfunc";
    }

    public SysUser getSysUser()
    {
        return sysUser;
    }

    public void setSysUser(SysUser sysUser)
    {
        this.sysUser = sysUser;
    }

    public String getReUserPassword()
    {
        return reUserPassword;
    }

    public void setReUserPassword(String reUserPassword)
    {
        this.reUserPassword = reUserPassword;
    }

    public String getUserName()
    {
        return userName;
    }

    public void setUserName(String userName)
    {
        this.userName = userName;
    }

    public String getOldUserName()
    {
        return oldUserName;
    }

    public void setOldUserName(String oldUserName)
    {
        this.oldUserName = oldUserName;
    }

    public String getUserPassword()
    {
        return userPassword;
    }

    public void setUserPassword(String userPassword)
    {
        this.userPassword = userPassword;
    }

    public String getUserId()
    {
        return userId;
    }

    public void setUserId(String userId)
    {
        this.userId = userId;
    }

    public String[] getPageIds()
    {
        return pageIds;
    }

    public void setPageIds(String[] pageIds)
    {
        this.pageIds = pageIds;
    }

    public AlgorithmFunc getAlgorithmFunc()
    {
        return algorithmFunc;
    }

    public void setAlgorithmFunc(AlgorithmFunc algorithmFunc)
    {
        this.algorithmFunc = algorithmFunc;
    }

    public FlashFile getFlashFile()
    {
        return flashFile;
    }

    public void setFlashFile(FlashFile flashFile)
    {
        this.flashFile = flashFile;
    }

    public int getUserStatus()
    {
        return userStatus;
    }

    public void setUserStatus(int userStatus)
    {
        this.userStatus = userStatus;
    }

    public Integer getUserType()
    {
        return userType;
    }

    public void setUserType(Integer userType)
    {
        this.userType = userType;
    }

    public String getSerialNo()
    {
        return serialNo;
    }

    public void setSerialNo(String serialNo)
    {
        this.serialNo = serialNo;
    }

    public String getDiskSerial()
    {
        return diskSerial;
    }

    public void setDiskSerial(String diskSerial)
    {
        this.diskSerial = diskSerial;
    }

    public String getMacAddr()
    {
        return macAddr;
    }

    public void setMacAddr(String macAddr)
    {
        this.macAddr = macAddr;
    }
}