seikyulogic.java

用strutshibernate做的项目

package com.dut.logic.logic;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import com.dut.dao.BatchDBConnectionUtil;
import com.dut.logic.db.Hagakicd;
import com.dut.logic.db.Kensyou;
import com.dut.logic.db.Kumi;
import com.dut.logic.db.Kyokusyo;
import com.dut.logic.db.Seikyu;
import com.dut.logic.db.Syouhin;
import com.dut.logic.db.Toukyucd;
import com.dut.logic.db.Tousen;
import com.dut.logic.util.DataTypeCheck;
import com.dut.struts.form.HikikaeJokyoActionForm;
import com.dut.struts.form.HikikaeNinkiActionForm;
import com.dut.struts.form.IdouInputActionForm;
import com.dut.struts.form.SeikyuInputActionForm;

public class SeikyuLogic {

	private static int sum_page = 1;

	private static int start_num = 1;

	private static int end_num = 1;

	private static int sun_count = 0;

	public static int getEnd_num() {
		return end_num;
	}

	public static void setEnd_num(int end_num) {
		SeikyuLogic.end_num = end_num;
	}

	public static int getStart_num() {
		return start_num;
	}

	public static void setStart_num(int start_num) {
		SeikyuLogic.start_num = start_num;
	}

	public static int getSum_page() {
		return sum_page;
	}

	public static void setSum_page(int sum_page) {
		SeikyuLogic.sum_page = sum_page;
	}

	public static int getSun_count() {
		return sun_count;
	}

	public static void setSun_count(int sun_count) {
		SeikyuLogic.sun_count = sun_count;
	}

	/**
	 * 将管内具中输入的数据进行处理,将最终的结果以没有重复数据的形式压入链表中,即链表中无重复数据
	 * 
	 * @method number_list 
	 * @param str
	 * @return List
	 * @author 王楠楠 2006-04-10
	 */
	
	public static List number_list(String str) {
		int min = 0;
		int max = 0;
		int key = 1;
		int index = 0;
		int aa = 1;
		int index2 = 0;
		int f = 1;
		int[] fu1 = new int[100];
		int[] dan = new int[str.length()];
		List list_no = new ArrayList();
		String[] str_no = new String[str.length()];
		int a1 = str.indexOf(",");
		int a2 = str.indexOf("-");
		
		/** 输入的字符串中没有","和"-"时,将数据直接压入链表 */
		if (a1 == -1 && a2 == -1) {
			list_no.add(str);
		} 
		
		/** 输入的字符串中只有"-"时,如果前面的数小于后面的数,将两个数范围内的所有数据都压入链表中 */
		else if (a1 == -1 && a2 != -1) {
			StringTokenizer st1 = new StringTokenizer(str, "-");
			String first = st1.nextToken();
			String last = st1.nextToken();

			min = Integer.parseInt(first);
			max = Integer.parseInt(last);

			while (min <= max) {
				list_no.add(Integer.toString(min));
				min++;
			}
		}
		/** 输入的字符串中只有","时,比较有无重复数据,有重复数据就将重复的删掉 */
		else if (a1 != -1 && a2 == -1) {
			StringTokenizer st2 = new StringTokenizer(str, ",");
			for (int i = 0; i < str.length(); i++) {
				str_no[i] = st2.nextToken();
				System.out.println("str  []  erererer------" + str_no[i]);
				System.out.println("key  ------" + key);
				if (st2.hasMoreTokens() == false) {
					break;
				} else {
					key++;
					continue;
				}
			}
			System.out.println("key  =====" + key);
			/** 检测重复数据 */
			for (int i = 0; i < key; i++) {
				System.out.println("qqqqqqqqqq=======" + str_no[i]);
				for (int j = i + 1; j < key; j++) {
					System.out.println("hhhhhhhh=======" + str_no[j]);
					if (str_no[i].equals(str_no[j])) {
						for (int k = j; k < key - 1; k++) {
							str_no[k] = str_no[k + 1];
						}
						key--;
					}
				}
			}
			System.out.println("key111111  =====" + key);
			/** 将无重复数据的数组压入链表 */
			for (int i = 0; i < key; i++) {
				list_no.add(str_no[i]);
			}
		} 
		/** 输入的字符串中既有","也有"-" */
		else if (a2 != -1 && a1 != -1) {
			StringTokenizer st = new StringTokenizer(str, ",");
			System.out.println("int d zhi shi ------>" + str.indexOf(","));
			System.out.println("str d zhi ======>" + st);
			for (int i = 0; i < str.length(); i++) {
				str_no[i] = st.nextToken();
				/** 判断是否有"-" */
				int num = str_no[i].indexOf("-");
				/** 没有"-" */
				if (num == -1) {
					index2++;
					/** 将数字添加到数组dan中 */
					while (f <= index2) {
						dan[f - 1] = Integer.parseInt(str_no[i]);
						f++;
					}

					if (st.hasMoreTokens() == false) {
						break;
					} else {
						continue;
					}

				} 
				/** 含有"-" */
				else if (num != -1) {
					StringTokenizer st1 = new StringTokenizer(str_no[i], "-");
					String first_no = st1.nextToken();
					String last_no = st1.nextToken();
					System.out.println("first_no d zhi =====>" + first_no);
					System.out.println("last_no d zhi =====>" + last_no);
					int no1 = Integer.parseInt(first_no);
					int no2 = Integer.parseInt(last_no);
					
					/** 将所有数据都赋值给一个数组fu1 */
					while (no1 <= no2) {
						fu1[aa - 1] = no1;
						aa++;
						index++;
						no1++;
					}

					if (st.hasMoreTokens() == false) {
						break;
					} else {
						continue;
					}
				}
			}
			
			/** 检测fu1数组中有无重复数据 */
			System.out.println("len ooooooooo" + index);
			for (int a = 0; a < index; a++) {
				for (int b = a + 1; b < index; b++) {
					if (fu1[a] == fu1[b]) {
						for (int k = b; k < index - 1; k++) {
							fu1[k] = fu1[k + 1];
						}
						index--;
					}
				}
			}
			
			/** 将无重复数据的所有数据赋值给数据b */
			int[] b = new int[index];
			for (int i = 0; i < index; i++) {
				b[i] = fu1[i];
				list_no.add(String.valueOf(b[i]));
				System.out.print(b[i] + ",");
			}
			
			/** 创建一个字符串数组,并且将数组dan与数组b中相同元素的下标存入数组c */
			String[] c = new String[index2];
			int count = 0;
			int flagf = 0;
			for (int dd = 0; dd < index2; dd++) {
				System.out.println("dan   2222 ------->" + dan[dd]);
				for (int j = 0; j < index; j++) {
					if (dan[dd] == b[j]) {
						flagf = 1;// has same number
					}
					System.out.println("count  222 ---->" + count);
				}

				if (flagf == 0) {
					c[count] = Integer.toString(dd);
					count++;
				}
				flagf = 0;
			}
			
			/** 将数组dan中不重复的数据赋值给数组last_dan */
			int[] last_dan = new int[count];
			int last_num = 0;
			for (int j = 0; j < c.length; j++) {
				if (c[j] == null || c[j].equals("")) {
					break;
				} else if (c[j] != null || !c[j].equals("")) {
					for (int i = 0; i < index2; i++) {

						if (Integer.parseInt(c[j]) == i) {
							last_dan[last_num] = dan[i];
							last_num++;
							break;
						}
					}
				}
			}

			/** 将数组last_dan压入链表 */
			for (int i = 0; i < last_num; i++) {
				list_no.add(String.valueOf(last_dan[i]));
				System.out.println("last d zhi is 11111>>>>" + last_dan[i]);
			}

		}
		return list_no;
	}

	/**
	 * 拼凑字符串,并调用查询数据库的方法,返回List
	 * 
	 * @param form
	 * @param list
	 * @return List list
	 * @author 王楠楠 2006-04-13
	 */

	public static List message_list(HikikaeJokyoActionForm form, List list,
			int num, int page) {
		int[] page_and_num = new int[3];
		List list_mess = new ArrayList();
		int nen = Integer.parseInt(form.getNen());
		int gyousya_mei = Integer.parseInt(form.getGyousya_mei());
		// List SearchDate = new ArrayList();
		String flag = "";
		String sql_str = "SELECT * FROM SEIKYU WHERE NEN = " + nen
				+ " AND HAGAKI_ID = " + gyousya_mei;
		/** 局所不为空 */
		if (form.getKyoku_id() != null && !form.getKyoku_id().equals("")) {
			String kyoku_id = form.getKyoku_id();
			int kyoku_id_first = Integer.parseInt(kyoku_id.substring(0, 2));
			String kyoku_id_last = kyoku_id.substring(2, 5);
			sql_str = sql_str + " AND KEN_ID = " + kyoku_id_first
					+ " AND KYOKU_ID = '" + kyoku_id_last + "'";
		}
		/** 管内具不为空 */
		if (form.getKen_id() != null && !form.getKen_id().equals("")) {
			System.out.println("cha xun shu ju ku");
			flag = list.get(0).toString();
			for (int i = 1; i < list.size(); i++) {

				if (list.get(i) == null || list.get(i).toString().equals("")) {
				} else {
					flag = flag + ","
							+ Integer.parseInt(list.get(i).toString());
				}
			}
			sql_str = sql_str + " AND KEN_ID in(" + flag + ")";
			System.out.println("sql_str eeeeeeee>>>>" + sql_str);
		}
		/** 赏品不为空 */
		if (form.getSyouhin_id() != null && !form.getSyouhin_id().equals("")) {
			int syouhin_id = Integer.parseInt(form.getSyouhin_id());
			sql_str = sql_str + " AND SYOUHIN_ID = " + syouhin_id;
		}
		/** 赏品请求年月日不为空 */
		if (form.getSeikyu_date1() != null
				&& !form.getSeikyu_date1().equals("")
				&& form.getSeikyu_date2() != null
				&& !form.getSeikyu_date2().equals("")) {
			String seikyu_date1 = form.getSeikyu_date1();
			String seikyu_date2 = form.getSeikyu_date2();
			sql_str = sql_str + " AND SEIKYU_DATE BETWEEN "
					+ SeikyuLogic.nen_S(seikyu_date1) + " AND "
					+ SeikyuLogic.nen_S(seikyu_date2);

		}
		/** 移动决定年月日不为空 */
		if (form.getKettei_date1() != null
				&& !form.getKettei_date1().equals("")
				&& form.getKettei_date2() != null
				&& !form.getKettei_date2().equals("")) {
			String kettei_date1 = form.getKettei_date1();
			String kettei_date2 = form.getKettei_date2();
			sql_str = sql_str + " AND KETTEI_DATE BETWEEN "
					+ SeikyuLogic.nen_S(kettei_date1) + " AND "
					+ SeikyuLogic.nen_S(kettei_date2);
		}
		/** 济或未济不为空 */
		if (form.getYesorno() != null && !form.getYesorno().equals("")) {
			String yes_or_no = form.getYesorno();
			if (yes_or_no.equals("yes")) {
				sql_str = sql_str + " AND TAISYO_FLG = 1 AND KETTEI_FLG = 1";
			} else if (yes_or_no.equals("no")) {
				sql_str = sql_str + " AND TAISYO_FLG = 0 AND KETTEI_FLG = 0";
			}
		}
		System.out.println("sql  ------->" + sql_str);
		/** 调用取得数据个数的函数 */
		page_and_num = Seikyu.getPagenum(num, page, sql_str);
		System.out.println("page_and_num[0]>>>>" + page_and_num[0]);
		System.out.println("page_and_num[1]>>>>" + page_and_num[1]);
		System.out.println("page_and_num[2]>>>>" + page_and_num[2]);
		SeikyuLogic.setSum_page(page_and_num[0]);
		/** 获取当前显示的信息的第一条在数据库中所处的位置 */
		SeikyuLogic.setStart_num(page_and_num[1]);
		/** 获取当前显示的信息的最后一条在数据库中所处的位置 */
		SeikyuLogic.setEnd_num(page_and_num[2]);
		/** 获取数据库中满足条件的所有信息个数 */
		SeikyuLogic.setSun_count(Seikyu.getCont(sql_str));
		System.out.println("page_and_num[0]>>>>" + SeikyuLogic.getSum_page());
		System.out.println("page_and_num[1]>>>>" + SeikyuLogic.getStart_num());
		System.out.println("page_and_num[2]>>>>" + SeikyuLogic.getEnd_num());
		
		/** 调用查询数据库,并且分页显示的方法 */
		list_mess = Seikyu.getPageBeanList(sql_str, num, page);

		System.out.println("list_mess   ========>" + list_mess);