using System;
using System.Data;
using System.Configuration;
using System.Data.Common;
using System.Collections;
using System.Collections.Generic;
using Wellan.Data;
using Wellan.Common;
using System.Transactions;
using System.ComponentModel;
using System.Text;
using System.IO;
using System.Web;
using System.Linq;
using System.Web.UI;

/// <summary>
/// 人員請假、加班、出差紀錄
/// </summary>
[DataObject]
public class RparDAC : Wellan.Data.WDAC
{
    //private string _tableName = "RPAR";
    //private string _select =
    //  @"SELECT TRDAT, TRMOD, TRUSR, RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, 
    //         RPTYP, RPTCT, RPFTR, RPDOC, APPNO, RPADT, RPAPN, RPANO, RPAPP, RPAPD, 
    //         RPAPU, RPAGT, RPRTM, RPETM, RPUST, RPTC1, RPTC2, RPTC3, RPRSN, RPAGM, 
    //         RPPLC ";
    //private string _insert =
    //  @" TRDAT, TRMOD, TRUSR, RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, 
    //   RPTYP, RPTCT, RPFTR, RPDOC, APPNO, RPADT, RPAPN, RPANO, RPAPP, RPAPD, 
    //   RPAPU, RPAGT, RPRTM, RPETM, RPUST, RPTC1, RPTC2, RPTC3, RPRSN, RPAGM, 
    //   RPPLC ";
    //private string _insertValue =
    //  @" @TRDAT, @TRMOD, @TRUSR, @RPREN, @RPNUM, @RAITM, @RPCNM, @RPPYN, @RPRDT, @RPEDT, 
    //   @RPTYP, @RPTCT, @RPFTR, @RPDOC, @APPNO, @RPADT, @RPAPN, @RPANO, @RPAPP, @RPAPD, 
    //   @RPAPU, @RPAGT, @RPRTM, @RPETM, @RPUST, @RPTC1, @RPTC2, @RPTC3, @RPRSN, @RPAGM, 
    //   @RPPLC ";
    //private string _from = " from RPAR ";
    //private string _where = " where 1=1 ";
    //private string _order = " order by RPREN ";

    private string 補休類別Where = " (RPTYP = '11' OR RPTYP = '13' OR RPTYP = '15') ";
    private string 事假類別Where = " (RPTYP = '02' OR RPTYP = '0B') ";
    private string 病假類別Where = " (RPTYP = '03') ";

    public RparDAC()
    {
    }

    public RparDAC(string connectionConfig, string connectionConfigName)
      : this()
    {
        this._connectionConfig = connectionConfig;
        this._connectionConfigName = connectionConfigName;
    }

    public RparDAC(WQuery query)
    {
        this._query = query;
    }

    /*
    public DataTable SelectOne(string rpren)
    {
      DbCommand cmd = Query.NewCommand();
      cmd.CommandText =
        @"SELECT TRDAT, TRMOD, TRUSR, RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, 
                 RPTYP, RPTCT / 60 AS RPTCT, RPFTR, RPDOC, APPNO, RPAPP, RPAPD, RPAPU, 
                 RPADT, RPAPN, RPANO, RPAGT, RPRTM, RPETM, RPUST, RPTC1 / 60 AS RPTC1, 
                 RPTC2 / 60 AS RPTC2, RPTC3 / 60 AS RPTC3, RPRSN, RPAGM, RPPLC
          FROM RPAR WHERE RPREN=@RPREN";
      AddParam(cmd, "RPREN", rpren);
      return Query.Select(cmd);
    }
    */

    [DataObjectMethod(DataObjectMethodType.Select)]
    public RPARList SelectOne(String RPREN)
    {
        RPARList result = new RPARList();
        IDataList list = result as IDataList;
        DbCommand cmdSelect = Query.NewCommand();
        cmdSelect.CommandText =
          @"SELECT 
               RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, RPTYP, RPFTR, RPDOC, 
               APPNO, RPADT, RPAPN, RPANO, RPAPP, RPAPD, RPAPU, RPAGT, RPAGM, RPRTM, 
               RPETM, RPUST, RPRSN, RPPLC, RPFPC, RPFAD, RPKMS, TRDAT, TRMOD, TRUSR,
               CAST(RPTCT AS INT) / 60 AS RPTCT, 
               ISNULL(CAST(RPTCT AS INT) % 60, 0) AS RPTMT,
               ISNULL(RPTC1, 0) / 60 AS RPTC1, 
               ISNULL(RPTC1, 0) % 60 AS RPTM1, 
               ISNULL(RPTC2, 0) / 60 AS RPTC2, 
               ISNULL(RPTC2, 0) % 60 AS RPTM2, 
               ISNULL(RPTC3, 0) / 60 AS RPTC3, 
               ISNULL(RPTC3, 0) % 60 AS RPTM3,
               ISNULL(RPTC4, 0) / 60 AS RPTC4, 
               ISNULL(RPTC4, 0) % 60 AS RPTM4,
               ISNULL(RPTC5, 0) / 60 AS RPTC5, 
               ISNULL(RPTC5, 0) % 60 AS RPTM5
            FROM RPAR WHERE RPREN=@RPREN";
        AddParam(cmdSelect, "RPREN", RPREN);
        Query.Select(cmdSelect, ref list);
        return result;
    }


    /// <summary>
    /// 取出某人某天的加班單
    /// </summary>
    /// <param name="RPNUM"></param>
    /// <param name="RPRDT"></param>
    /// <returns></returns>
    [DataObjectMethod(DataObjectMethodType.Select)]
    public RPARList SelectOverTimeOneDay(String RPNUM, DateTime RPRDT)
    {
        RPARList result = new RPARList();
        IDataList list = result as IDataList;
        DbCommand cmdSelect = Query.NewCommand();
        cmdSelect.CommandText =
          @"SELECT 
               RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, RPTYP, RPFTR, RPDOC, 
               APPNO, RPADT, RPAPN, RPANO, RPAPP, RPAPD, RPAPU, RPAGT, RPAGM, RPRTM, 
               RPETM, RPUST, RPRSN, RPPLC, RPFPC, RPFAD, RPKMS, TRDAT, TRMOD, TRUSR,
               RPTCT, RPTC1, RPTC2, RPTC3, RPTC4, RPTC5, 0 RPTMT, 0 RPTM1, 0 RPTM2, 0 RPTM3, 0 RPTM4, 0 RPTM5
            FROM RPAR 
            WHERE RPNUM=@RPNUM 
               AND RPRDT=@RPRDT 
               AND RPTYP LIKE '1%' 
               AND ((RPAPN IS NOT NULL AND RPAPN<>'D' AND (RPAPP IS NULL OR RPAPP<>'N')) OR (RPAPN IS NULL))
            ORDER BY RPRTM";
        AddParam(cmdSelect, "RPNUM", RPNUM);
        AddParam(cmdSelect, "RPRDT", RPRDT);
        Query.Select(cmdSelect, ref list);
        return result;
    }


    /// <summary>
    /// 更新加班時數
    /// </summary>
    /// <param name="RPREN"></param>
    /// <param name="RPTCT"></param>
    /// <param name="RPTC1"></param>
    /// <param name="RPTC2"></param>
    /// <param name="RPTC3"></param>
    public void UpdateOverTimeHours(string RPREN, int RPTCT, int RPTC1, int RPTC2, int RPTC3, int RPTC4, int RPTC5,
        int RPTA1, int RPTA2, int RPTA3, int RPTA4, int RPTA5)
    {
        DbCommand cmdUpdate = Query.NewCommand();
        cmdUpdate.CommandText =
            @"UPDATE RPAR SET RPTCT=@RPTCT, RPTC1=@RPTC1, RPTC2=@RPTC2, RPTC3=@RPTC3, RPTC4=@RPTC4, RPTC5=@RPTC5,
                RPFTR=@RPFTR, RPTA1=@RPTA1, RPTA2=@RPTA2, RPTA3=@RPTA3, RPTA4=@RPTA4, RPTA5=@RPTA5
              WHERE RPREN=@RPREN";
        AddParam(cmdUpdate, "RPREN", RPREN);
        AddParam(cmdUpdate, "RPTCT", RPTCT);
        AddParam(cmdUpdate, "RPTC1", RPTC1);
        AddParam(cmdUpdate, "RPTC2", RPTC2);
        AddParam(cmdUpdate, "RPTC3", RPTC3);
        AddParam(cmdUpdate, "RPTC4", RPTC4);
        AddParam(cmdUpdate, "RPTC5", RPTC5);
        AddParam(cmdUpdate, "RPFTR", RPTA1 + RPTA2 + RPTA3 + RPTA4 + RPTA5);
        AddParam(cmdUpdate, "RPTA1", RPTA1);
        AddParam(cmdUpdate, "RPTA2", RPTA2);
        AddParam(cmdUpdate, "RPTA3", RPTA3);
        AddParam(cmdUpdate, "RPTA4", RPTA4);
        AddParam(cmdUpdate, "RPTA5", RPTA5);
        Query.ExecuteNonQuery(cmdUpdate);
    }

    /// <param name="rpnum">員工編號</param>
    /// <param name="rprdt">請假日期</param>
    /// <returns></returns>
    public int Get可用補休(string rpnum, DateTime rprdt)
    {
        // 取得補休補登的可用時數
        RbsaDAC rbsaDao = new RbsaDAC(Query);

        // 取得員工在請假日期所在專案的補休期限設定
        int otd = new GetData(Query).GetBPOTD_DATE_BPENO(rprdt, rpnum);

        // 取得加班補休的可用時數
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(@"
          SELECT SUM(RPTCT - ISNULL(RPUST, 0)) 
          FROM RPAR 
          WHERE RPNUM = @RPNUM 
            AND {0}
            AND RPRDT >= @RPRDT
            AND ((RPAPN IS NOT NULL AND RPAPN<>'D' AND RPAPN=RPANO AND RPAPP='Y') OR (RPAPN IS NULL))
            AND (RPUST IS NULL OR RPUST<RPTCT)
            AND RPRDT >= dbo.BPSDY(@RPNUM)            -- 20150803 增加加班日期需大於等於到職日期的條件
            AND RPRDT < @TODAY                        -- 20160429 增加加班日期需小於今天的條件
            ", 補休類別Where);
        AddParam(cmd, "RPNUM", rpnum);
        AddParam(cmd, "RPRDT", rprdt.AddMonths(-otd));
        AddParam(cmd, "TODAY", DateTime.UtcNow.AddHours(8).Date);

        return rbsaDao.Get可用補休(rpnum, rprdt) + WDAC.GetInt32Value(Query.ExecuteScalar(cmd));
    }

    /// <param name="rpnum">員工編號</param>
    /// <param name="rprdt">請假日期</param>
    /// <returns></returns>
    public int Get已請事假(string rpnum, DateTime rprdt, string rprenExclude)
    {
        return Get年度已請假時數(rpnum, rprdt, 事假類別Where, rprenExclude);
    }

    /// <param name="rpnum">員工編號</param>
    /// <param name="rprdt">請假日期</param>
    /// <returns></returns>
    public int Get已請病假(string rpnum, DateTime rprdt, string rprenExclude)
    {
        return Get年度已請假時數(rpnum, rprdt, 病假類別Where, rprenExclude);
    }


    public int Get年度已請假時數(string rpnum, DateTime rprdt, string 請假類別Where, string rprenExclude)
    {
        var yearBegin = new DateTime(rprdt.Year, 1, 1);
        var yearEnd = new DateTime(rprdt.Year, 12, 31);

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(@"
          SELECT * 
          FROM RPAR 
          WHERE RPNUM = @RPNUM 
            AND {0}
            AND ((RPRDT >= @DATE_1 AND RPRDT < @DATE_2) OR (RPEDT >= @DATE_1 AND RPEDT < @DATE_2))
            -- AND ((RPAPN IS NOT NULL AND RPAPN <> 'D') OR (RPAPN IS NULL))
            AND ((RPAPN IS NOT NULL AND RPAPN <> 'D' AND RPAPP <> 'N') OR (RPAPN IS NULL))
            AND RPRDT >= dbo.BPSDY(@RPNUM)
            ", 請假類別Where);
        AddParam(cmd, "RPNUM", rpnum);
        AddParam(cmd, "DATE_1", yearBegin);
        AddParam(cmd, "DATE_2", yearEnd.AddDays(1));

        var d = Query.Select(cmd);

        // 抓加班時數計算方式
        BpaaDAC bpaa = new BpaaDAC(Query);

        DataTable d1 = Query.Select(cmd);
        TimeCalc timeCalc = new TimeCalc();
        int 請假 = 0;

        foreach (DataRow r1 in d1.Rows)
        {
            string rpren = GetStringValue(r1["RPREN"]);

            if (rpren == rprenExclude)
                continue;

            string rppyn = GetStringValue(r1["RPPYN"]);
            DateTime 起日 = GetDateTimeValue(r1["RPRDT"]);
            DateTime 迄日 = GetDateTimeValue(r1["RPEDT"]);
            string 起時 = GetStringValue(r1["RPRTM"]);
            string 迄時 = GetStringValue(r1["RPETM"]);
            string 類別 = GetStringValue(r1["RPTYP"]);
            string bpott = bpaa.GetOverTimeType(rppyn);

            if (起日 >= yearBegin && 起日 <= yearEnd && 迄日 >= yearBegin && 迄日 <= yearEnd)
                請假 += GetInt32Value(r1["RPTCT"]);
            else
            {
                DateTime 日期 = 起日;
                while (日期 <= 迄日)
                {
                    if (日期 >= yearBegin && 日期 <= yearEnd)
                        請假 += timeCalc.計算請假當日時數(rpnum, 日期, 起日, 迄日, 起時, 迄時, 類別, bpott == "1");
                    日期 = 日期.AddDays(1);
                }
            }
        }

        return 請假;
    }


    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Get可用補休明細(string rpnum, DateTime rprdt)
    {
        // 取得員工在請假日期所在專案的補休期限設定
        int otd = new GetData(Query).GetBPOTD_DATE_BPENO(rprdt, rpnum);

        // 取得補休補登的可用時數
        RbsaDAC rbsaDao = new RbsaDAC(Query);

        // 20150803 增加加班日期需大於等於到職日期的條件
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(@"
            SELECT RPRDT AS 日期, '加班' AS 類別, 
                FLOOR(ISNULL(RPTCT, 0) / 60) AS 可補時數, 
                FLOOR(ISNULL(RPUST, 0) / 60) AS 已補時數, 
                ISNULL(RPTCT, 0) - FLOOR(ISNULL(RPTCT, 0) / 60) * 60 AS 可補分數, 
                ISNULL(RPUST, 0) - FLOOR(ISNULL(RPUST, 0) / 60) * 60 AS 已補分數, 
                DATEADD(MONTH, @OTD, RPRDT) AS 補休期限 
            FROM RPAR 
            WHERE RPNUM=@RPNUM 
                AND {0} 
                AND RPRDT >= @RPRDT
                AND ((RPAPN IS NOT NULL AND RPAPN<>'D' AND RPAPN=RPANO AND RPAPP='Y') OR (RPAPN IS NULL))
                AND (RPUST IS NULL OR RPUST<RPTCT)
                AND RPRDT >= dbo.BPSDY(@RPNUM)          -- 加班日期需大於等於到職日期
                AND RPRDT < @TODAY                      -- 20160429 增加加班日期需小於今天的條件
            UNION ALL
            SELECT RBDAT AS 日期, '補休補登' AS 類別, 
                FLOOR(ISNULL(RBTCT, 0) / 60) AS 可補時數, 
                FLOOR(ISNULL(RBUST, 0) / 60) AS 已補時數, 
                ISNULL(RBTCT, 0) - FLOOR(ISNULL(RBTCT, 0) / 60) * 60 AS 可補分數, 
                ISNULL(RBUST, 0) - FLOOR(ISNULL(RBUST, 0) / 60) * 60 AS 已補分數, 
                DATEADD(MONTH, @OTD, RBDAT) AS 補休期限
            FROM RBSA 
            WHERE RBENO = @RPNUM 
                AND RBDAT >= @RPRDT 
                AND (RBUST IS NULL OR RBUST<RBTCT)
                AND RBDAT >= dbo.BPSDY(@RPNUM)           -- 補休補登日期需大於等於到職日期
                AND RBDAT < @TODAY                       -- 20160429 增加加班日期需小於今天的條件
            ORDER BY 日期", 補休類別Where);
        AddParam(cmd, "RPNUM", rpnum);
        AddParam(cmd, "RPRDT", rprdt.AddMonths(-otd));
        AddParam(cmd, "TODAY", DateTime.UtcNow.AddHours(8).Date);
        AddParam(cmd, "OTD", otd);
        return Query.Select(cmd);
    }

    /// <summary>
    /// 沖補休
    /// </summary>
    /// <param name="rpren">請假單號</param>
    /// <param name="rpnum">員工編號</param>
    /// <param name="rprdt">請假日期</param>
    /// <param name="rptct">請假時數</param>
    /// <returns>沖補休備註</returns> 
    public string 沖補休(DbTransaction tran, string rpren, string rpnum, DateTime rprdt, int rptct)
    {
        string result = "";

        // 取得員工在請假日期所在專案的補休期限設定
        int otd = new GetData(Query).GetBPOTD_DATE_BPENO(rprdt, rpnum);

        // 先呼叫補休補登的沖補休
        RbsaDAC rbsaDao = new RbsaDAC(Query);
        rptct = rbsaDao.沖補休(tran, rpren, rpnum, rprdt, rptct, out result);

        if (rptct > 0)
        {
            // 取出可沖單號
            DbCommand cmd = Query.NewCommand();
            cmd.CommandText = String.Format(
            @"SELECT RPREN, RPTCT, RPUST, RPRDT 
                FROM RPAR 
                WHERE RPNUM = @RPNUM 
                  AND {0} 
                  AND RPRDT >= @RPRDT                                                    -- 補休6個月之內有效
                  AND ((RPAPN IS NOT NULL AND RPAPN <> 'D' AND RPAPN = RPANO AND RPAPP = 'Y') OR (RPAPN IS NULL))
                  AND (RPUST IS NULL OR RPUST < RPTCT)
                  AND RPRDT >= dbo.BPSDY(@RPNUM)                                         -- 到職日之後
                  AND RPRDT < @TODAY                                                     -- 今天之前
                ORDER BY RPRDT, RPREN", 補休類別Where);
            AddParam(cmd, "RPNUM", rpnum);
            AddParam(cmd, "RPRDT", rprdt.AddMonths(-otd));
            AddParam(cmd, "TODAY", DateTime.UtcNow.AddHours(8).Date);
            DataTable data = Query.Select(cmd, tran);

            // 準備新增補休沖銷紀錄 SQL
            DbCommand cmdInsertRpac = Query.NewCommand();
            cmdInsertRpac.CommandText =
              @"INSERT INTO RPAC
                (RPREN, RPREX, RPTCT, TRDAT, TRMOD, TRUSR) 
                  VALUES 
                (@RPREN, @RPREX, @RPTCT, GETDATE(), 'INSERT', @TRUSR)";

            // 準備回填已沖時數 SQL
            DbCommand cmdUpdateRpar = Query.NewCommand();
            cmdUpdateRpar.CommandText =
              @"UPDATE RPAR
                SET RPUST = (SELECT SUM(RPTCT) FROM RPAC WHERE RPREX=RPAR.RPREN)
                WHERE RPREN = @RPREN";

            // 用來儲存要重新加總的 RPAR 的 RPREN，以免 RPAR 重複 UPDATE 被 LOCK
            List<string> RbarRpren = new List<string>();

            foreach (DataRow row in data.Rows)
            {
                // 一筆一筆的寫沖銷紀錄
                string rpren1 = WDAC.GetStringValue(row["RPREN"]);
                int rptct1 = WDAC.GetInt32Value(row["RPTCT"]);
                int rpust1 = WDAC.GetInt32Value(row["RPUST"]);
                DateTime rprdt1 = WDAC.GetDateTimeValue(row["RPRDT"]);

                int tct = rptct > rptct1 - rpust1 ? rptct1 - rpust1 : rptct;
                rptct -= tct;

                AddParam(cmdInsertRpac, "RPREN", rpren);
                AddParam(cmdInsertRpac, "RPREX", rpren1);
                AddParam(cmdInsertRpac, "RPTCT", tct);
                AddParam(cmdInsertRpac, "TRUSR", rpnum);
                Query.ExecuteNonQuery(tran.Connection, tran, cmdInsertRpac);

                result += String.Format("{0:MM/dd}-{1}:{2}、", rprdt1, tct / 60, tct % 60);

                if (!RbarRpren.Contains(rpren1))
                    RbarRpren.Add(rpren1);

                if (rptct <= 0)
                    break;
            }

            // 重新加總 RPAR 的已用時數 
            foreach (string rpren1 in RbarRpren)
            {
                AddParam(cmdUpdateRpar, "RPREN", rpren1);
                Query.ExecuteNonQuery(tran.Connection, tran, cmdUpdateRpar);
            }
        }

        if (result.Length > 0)
            return result.Substring(0, result.Length - 1);
        else
            return result;
    }

    public void 取消沖補休(DbTransaction tran, string rpren)
    {
        // 先呼叫補休補登的取消沖補休
        RbsaDAC rbsaDao = new RbsaDAC(Query);
        rbsaDao.取消沖補休(tran, rpren);

        // 取出本張單據沖銷的紀錄
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = @"SELECT RPREN, RPREX, RPTCT FROM RPAC WHERE RPREN=@RPREN";
        AddParam(cmd, "RPREN", rpren);
        DataTable data = Query.Select(cmd, tran);

        DbCommand cmdDeleteRpac = Query.NewCommand();
        cmdDeleteRpac.CommandText = @"DELETE FROM RPAC
      WHERE RPREN = @RPREN AND RPREX = @RPREX";

        DbCommand cmdUpdateRpar = Query.NewCommand();
        cmdUpdateRpar.CommandText = @"UPDATE RPAR
      SET RPUST = (SELECT SUM(RPTCT) FROM RPAC WHERE RPREX=RPAR.RPREN)
      WHERE RPREN = @RPREN";

        // 用來儲存要重新加總的 RPAR 的 RPREN，以免 RPAR 重複 UPDATE 被 LOCK
        List<string> RbarRpren = new List<string>();

        foreach (DataRow row in data.Rows)
        {
            // 還原被沖銷單據的被沖銷時數
            string rprex1 = WDAC.GetStringValue(row["RPREX"]);
            int rptct1 = WDAC.GetInt32Value(row["RPTCT"]);

            AddParam(cmdDeleteRpac, "RPREN", rpren);
            AddParam(cmdDeleteRpac, "RPREX", rprex1);
            Query.ExecuteNonQuery(tran.Connection, tran, cmdDeleteRpac);

            if (!RbarRpren.Contains(rprex1))
                RbarRpren.Add(rprex1);
        }

        // 重新加總 RPAR 的已用時數 
        foreach (string rpren1 in RbarRpren)
        {
            AddParam(cmdUpdateRpar, "RPREN", rpren1);
            Query.ExecuteNonQuery(tran.Connection, tran, cmdUpdateRpar);
        }
    }

    /// <summary>
    /// 送簽
    /// </summary>
    /// <param name="RPREN">單號</param>
    /// <param name="RPANO">目前關卡</param>
    /// <param name="RPAPU">簽核人員</param>
    public void 送簽(DbTransaction tran, object RPREN, object RPANO, object RPAPU)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPANO = @RPANO,
            RPAPP = NULL,
            RPAPD = NULL,
            RPAPU = @RPAPU,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = @RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPANO", RPANO);
        AddParam(cmd, "RPAPU", RPAPU);
        AddParam(cmd, "RPREN", RPREN);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    /// <summary>
    /// 抽單
    /// </summary>
    /// <param name="RPREN">單號</param>
    /// <param name="RPAPU">簽核人員</param>
    public void 抽單(DbTransaction tran, object RPREN, object RPAPU)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPAPN = 'D',
            RPANO = 'D',
            RPAPP = NULL,
            RPAPD = NULL,
            RPAPU = @RPAPU,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = @RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPAPU", RPAPU);
        AddParam(cmd, "RPREN", RPREN);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    /// <summary>
    /// 取消抽單
    /// </summary>
    /// <param name="RPREN">單號</param>
    /// <param name="RPAPN">應簽關數</param>
    /// <param name="RPANO">前關關卡</param>
    /// <param name="RPAPP">前關簽核結果</param>
    /// <param name="RPAPD">前關簽核日期</param>
    /// <param name="RPAPU">前關簽核人員</param>
    public void 取消抽單(DbTransaction tran, string RPREN, string RPAPN, string RPANO, string RPAPP, DateTime RPAPD, string RPAPU)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPAPN = @RPAPN,
            RPANO = @RPANO,
            RPAPP = @RPAPP,
            RPAPD = @RPAPD,
            RPAPU = @RPAPU,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = @RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPAPN", RPAPN);
        AddParam(cmd, "RPANO", RPANO);
        AddParam(cmd, "RPAPP", RPAPP);
        if (RPAPD.Ticks > 0)
            AddParam(cmd, "RPAPD", RPAPD);
        else
            AddParam(cmd, "RPAPD", DBNull.Value);
        AddParam(cmd, "RPAPU", RPAPU);
        AddParam(cmd, "RPREN", RPREN);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    /// <summary>
    /// 簽核
    /// </summary>
    /// <param name="rpren">單號</param>
    /// <param name="rpapp">本關簽核結果</param>
    /// <param name="rpapd">簽核日期</param>
    public void 簽核(DbTransaction tran, string rpren, string rpapp, DateTime rpapd)
    {
        // 先取出這張單據的資料，用以判斷是何種單據
        RPARList d = SelectOne(rpren);
        if (d.Count > 0)
        {
            string rptyp = GetStringValue(d[0].RPTYP);
            string rpapn = GetStringValue(d[0].RPAPN);

            // 如果不核准或是核准的是抽單
            if (rpapp == "N" || (rpapp == "Y" && rpapn == "D"))
            {
                // 補休，要將補休沖回去
                if (rptyp == RPAR_TYPE.T00_補休)
                {
                    取消沖補休(tran, rpren);
                }

                // 特休，要將特休沖回去
                if (rptyp == RPAR_TYPE.T01_特休)
                {
                    new RyerDAC(Query).取消沖特休(tran, rpren);
                }
            }
        }

        // 更新簽核結果
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPAPP = @RPAPP,
            RPAPD = @RPAPD,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPAPP", rpapp);
        AddParam(cmd, "RPAPD", rpapd);
        AddParam(cmd, "RPREN", rpren);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    /// <summary>
    /// 退回上一關
    /// </summary>
    /// <param name="RPREN">單號</param>
    public void 退回上一關(DbTransaction tran, object RPREN, object 上一關簽核人)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPANO = RPANO - 1,
            RPAPP = NULL,
            RPAPD = NULL,
            RPAPU = @RPAPU,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPAPU", 上一關簽核人);
        AddParam(cmd, "RPREN", RPREN);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    /// <summary>
    /// 取消本關
    /// </summary>
    /// <param name="RPREN">單號</param>
    public void 取消本關(DbTransaction tran, object RPREN)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"UPDATE RPAR
        SET RPAPP = NULL,
            RPAPD = NULL,
            TRDAT = GETDATE(),
            TRMOD = 'UPDATE',
            TRUSR = RPAPU
        WHERE RPREN = @RPREN";
        AddParam(cmd, "RPREN", RPREN);
        Query.ExecuteNonQuery(tran.Connection, tran, cmd);
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select未簽核ByUser(string UserId, string RPTYP, string RPNUM)
    {
        DbCommand cmd = Query.NewCommand();
        var wheres = new List<string>();

        if (!string.IsNullOrEmpty(RPTYP))
        {
            var rptypWhere = new List<string>();
            foreach (var rptyp in RPTYP.Split(','))
            {
                rptypWhere.Add(string.Format(" RPTYP LIKE '{0}' ", rptyp));
            }
            wheres.Add(string.Format(" AND ({0}) ", string.Join(" OR ", rptypWhere.ToArray())));
        }

        if (!string.IsNullOrEmpty(RPNUM))
        {
            var rpnumWhere = new List<string>();
            foreach (var rpnum in RPNUM.Split(','))
            {
                rpnumWhere.Add(string.Format("'{0}'", rpnum));
            }
            wheres.Add(string.Format(" AND RPNUM IN ({0}) ", string.Join(",", rpnumWhere.ToArray())));
        }

        cmd.CommandText = string.Format(
            @"SELECT 
                A.RPREN, A.RPNUM, A.RAITM, A.RPCNM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, 
                A.RPFTR, A.RPDOC, A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, 
                A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, A.RPUST,
                A.RPRSN, A.RPAGM, A.RPPLC, B.BPPYM, 
                B.BPOTT,
                CAST(A.RPTCT AS INT) / 60 AS RPTCT, 
                ISNULL(CAST(A.RPTCT AS INT) % 60, 0) AS RPTMT,
                ISNULL(A.RPTC1, 0) / 60 AS RPTC1, 
                ISNULL(A.RPTC1, 0) % 60 AS RPTM1, 
                ISNULL(A.RPTC2, 0) / 60 AS RPTC2, 
                ISNULL(A.RPTC2, 0) % 60 AS RPTM2, 
                ISNULL(A.RPTC3, 0) / 60 AS RPTC3, 
                ISNULL(A.RPTC3, 0) % 60 AS RPTM3,
                ISNULL(A.RPTC4, 0) / 60 AS RPTC4, 
                ISNULL(A.RPTC4, 0) % 60 AS RPTM4,
                ISNULL(A.RPTC5, 0) / 60 AS RPTC5, 
                ISNULL(A.RPTC5, 0) % 60 AS RPTM5,
                A.TRDAT
            FROM RPAR A INNER JOIN BPAA B ON A.RPPYN=B.BPPYN
            WHERE RPAPU=@RPAPU AND RPAPD IS NULL {0}
            ORDER BY A.RPRDT DESC", string.Join(" ", wheres.ToArray()));
        AddParam(cmd, "RPAPU", UserId);

        return Query.Select(cmd);
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select已簽核ByUser(string UserId)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"SELECT A.RPREN, A.RPNUM, A.RAITM, A.RPCNM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, 
                A.RPFTR, A.RPDOC, A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, 
                A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, A.RPUST, 
                A.RPRSN, A.RPAGM, A.RPPLC, B.BPPYM, C.RPAPP AS CRPAPP, C.RPDAT AS CRPDAT, C.RPENO AS CRPENO,
                B.BPOTT,
                CAST(A.RPTCT AS INT) / 60 AS RPTCT, 
                ISNULL(CAST(A.RPTCT AS INT) % 60, 0) AS RPTMT,
                ISNULL(A.RPTC1, 0) / 60 AS RPTC1, 
                ISNULL(A.RPTC1, 0) % 60 AS RPTM1, 
                ISNULL(A.RPTC2, 0) / 60 AS RPTC2, 
                ISNULL(A.RPTC2, 0) % 60 AS RPTM2, 
                ISNULL(A.RPTC3, 0) / 60 AS RPTC3, 
                ISNULL(A.RPTC3, 0) % 60 AS RPTM3,
                ISNULL(A.RPTC4, 0) / 60 AS RPTC4, 
                ISNULL(A.RPTC4, 0) % 60 AS RPTM4,
                ISNULL(A.RPTC5, 0) / 60 AS RPTC5, 
                ISNULL(A.RPTC5, 0) % 60 AS RPTM5
            FROM RPAR A INNER JOIN BPAA B ON A.RPPYN=B.BPPYN
              INNER JOIN RPAB C ON A.RPREN=C.RPREN
            WHERE C.RPENO=@RPENO
              AND 
                (
                     ( C.RPAPN = C.RPANO AND C.RPDAT IS NOT NULL)         -- 最後一關且已簽
                  OR (A.RPANO='2' AND C.RPANO='1' AND A.RPAPD IS NULL)    -- 是上關且本關未簽
                  OR (A.RPANO='3' AND C.RPANO='2' AND A.RPAPD IS NULL)    -- 是上關且本關未簽
                  OR (A.RPAPP='N')                                        -- 不核准
                )
            ORDER BY A.RPRDT DESC";
        AddParam(cmd, "RPENO", UserId);
        return Query.Select(cmd);
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select我的申請(string UserId, DateTime Date1, DateTime Date2, string RPTYP, string RPAPP)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"SELECT A.RPREN, A.RPNUM, A.RAITM, A.RPCNM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, 
                A.RPFTR, A.RPDOC, A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, 
                A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, A.RPUST,
                A.RPRSN, A.RPAGM, A.RPPLC, C.RPENO AS CRPENO,
                B.BPOTT,
                CAST(A.RPTCT AS INT) / 60 AS RPTCT, 
                ISNULL(CAST(A.RPTCT AS INT) % 60, 0) AS RPTMT,
                ISNULL(A.RPTC1, 0) / 60 AS RPTC1, 
                ISNULL(A.RPTC1, 0) % 60 AS RPTM1, 
                ISNULL(A.RPTC2, 0) / 60 AS RPTC2, 
                ISNULL(A.RPTC2, 0) % 60 AS RPTM2, 
                ISNULL(A.RPTC3, 0) / 60 AS RPTC3, 
                ISNULL(A.RPTC3, 0) % 60 AS RPTM3,
                ISNULL(A.RPTC4, 0) / 60 AS RPTC4, 
                ISNULL(A.RPTC4, 0) % 60 AS RPTM4,
                ISNULL(A.RPTC5, 0) / 60 AS RPTC5, 
                ISNULL(A.RPTC5, 0) % 60 AS RPTM5
            FROM RPAR A
              INNER JOIN BPAA B ON A.RPPYN=B.BPPYN
              INNER JOIN RPAB C ON A.RPREN=C.RPREN AND C.RPANO=A.RPANO
            WHERE A.RPNUM = @RPENO 
              AND A.RPRDT >= @RPRDT1 AND A.RPRDT < @RPRDT2
              AND A.RPTYP LIKE @RPTYP ";

        switch (RPAPP)
        {
            case "YES":
                cmd.CommandText += " AND A.RPAPP = 'Y' ";
                break;
            case "NO":
                cmd.CommandText += " AND A.RPAPP = 'N' ";
                break;
            case "NULL":
                cmd.CommandText += " AND (A.RPAPP = '' OR A.RPAPP IS NULL) ";
                break;
            default:
                break;
        }

        cmd.CommandText += " ORDER BY A.RPRDT DESC";
        AddParam(cmd, "RPENO", UserId);
        AddParam(cmd, "RPRDT1", Date1);
        AddParam(cmd, "RPRDT2", Date2.AddDays(1));
        AddParam(cmd, "RPTYP", RPTYP);
        return Query.Select(cmd);
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select我的督導專案(string UserId, DateTime Date1, DateTime Date2, string RPTYP, string RPPYN, List<string> RPNUM, bool all)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = string.Format(
          @"SELECT A.RPREN, A.RPNUM, A.RAITM, A.RPCNM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, 
                A.RPFTR, A.RPDOC, A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, 
                A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, A.RPUST,
                A.RPRSN, A.RPAGM, A.RPPLC, B.BPPYM,
                B.BPOTT,
                CAST(A.RPTCT AS INT) / 60 AS RPTCT, 
                ISNULL(CAST(A.RPTCT AS INT) % 60, 0) AS RPTMT,
                ISNULL(A.RPTC1, 0) / 60 AS RPTC1, 
                ISNULL(A.RPTC1, 0) % 60 AS RPTM1, 
                ISNULL(A.RPTC2, 0) / 60 AS RPTC2, 
                ISNULL(A.RPTC2, 0) % 60 AS RPTM2, 
                ISNULL(A.RPTC3, 0) / 60 AS RPTC3, 
                ISNULL(A.RPTC3, 0) % 60 AS RPTM3,
                ISNULL(A.RPTC4, 0) / 60 AS RPTC4, 
                ISNULL(A.RPTC4, 0) % 60 AS RPTM4,
                ISNULL(A.RPTC5, 0) / 60 AS RPTC5, 
                ISNULL(A.RPTC5, 0) % 60 AS RPTM5
            FROM RPAR A 
              INNER JOIN BPAA B ON A.RPPYN=B.BPPYN          
            WHERE EXISTS (SELECT BSPYN FROM BSGP WHERE BSENO=@RPENO AND BSLVL IN ('1', '3') AND BSFLW='差勤' AND BSPYN=A.RPPYN)
              AND {0} ", RPTYP.Contains("%") ? string.Format("A.RPTYP LIKE '{0}'", RPTYP) : string.Format("A.RPTYP IN ({0})", RPTYP));

        if (RPPYN != null && RPPYN.Length > 0)
            cmd.CommandText += string.Format(" AND A.RPPYN IN ({0}) ", RPPYN);
        else
            return new DataTable();

        if (RPNUM != null && RPNUM.Count > 0)
            cmd.CommandText += String.Format(" AND A.RPNUM IN ({0}) ", WDAC.GetIN(RPNUM));

        if (Date1.Ticks > 0 && Date2.Ticks > 0)
        {
            cmd.CommandText += " AND A.RPRDT >= @RPRDT1 AND A.RPRDT < @RPRDT2 ";
        }
        else if (Date1.Ticks > 0 && Date2.Ticks == 0)
        {
            cmd.CommandText += " AND A.RPRDT >= @RPRDT1 ";
        }
        else if (Date1.Ticks == 0 && Date2.Ticks > 0)
        {
            cmd.CommandText += " AND A.RPRDT < @RPRDT2 ";
        }

        if (!all) 
        {
            cmd.CommandText += " AND A.RPAPN <> 'D' AND A.RPAPN = A.RPANO AND A.RPAPP = 'Y' ";
        }

        cmd.CommandText += " ORDER BY A.RPRDT DESC ";
        AddParam(cmd, "RPENO", UserId);
        AddParam(cmd, "RPRDT1", Date1);
        AddParam(cmd, "RPRDT2", Date2.AddDays(1));
        return Query.Select(cmd);
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select我的督導專案人員(string UserId, DateTime Date1, DateTime Date2, string RPTYP, string RPPYN)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = string.Format(
          @"SELECT DISTINCT A.RPNUM, A.RPNUM + ' ' + C.BPNME AS BPNME
        FROM RPAR A 
          INNER JOIN BPAA B ON A.RPPYN=B.BPPYN
          INNER JOIN BPSNView C ON A.RPNUM=C.BPENO          
        WHERE EXISTS (SELECT BSPYN FROM BSGP WHERE BSENO=@RPENO AND BSLVL IN ('1', '3') AND BSFLW='差勤' AND BSPYN=A.RPPYN)
          AND A.RPRDT >= @RPRDT1 AND A.RPRDT < @RPRDT2
          AND {0} ", RPTYP.Contains("%") ? string.Format("A.RPTYP LIKE '{0}'", RPTYP) : string.Format("A.RPTYP IN ({0})", RPTYP));
        if (RPPYN != null && RPPYN.Length > 0)
            cmd.CommandText += string.Format(" AND A.RPPYN IN ({0}) ", RPPYN);
        cmd.CommandText += " ORDER BY A.RPNUM ";
        AddParam(cmd, "RPENO", UserId);
        AddParam(cmd, "RPRDT1", Date1);
        AddParam(cmd, "RPRDT2", Date2.AddDays(1));
        return Query.Select(cmd);
    }

    public DataTable Select報表資料_013(DateTime 年月, string 年度專案, string 類型)
    {
        DateTime 月初 = 年月.AddDays(-年月.Day + 1);

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"SELECT A.RPREN, A.RPNUM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, A.RPTCT, A.RPFTR, A.RPDOC, 
          A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, 
          A.RPUST, A.RPTC1, A.RPTC2, A.RPTC3, A.RPTC4, A.RPTC5, A.RPRSN, A.RPAGM, A.RPPLC, 
          B.BPNME, C.RABRH, C.RAJNO, D.BSRMK AS 站別, E.BPJME AS 職稱
        FROM RPAR A
          LEFT OUTER JOIN BPSNView B ON B.BPENO = A.RPNUM
          LEFT OUTER JOIN RASN C ON A.RPPYN = C.RAPYN AND A.RPNUM = C.RANUM
          LEFT OUTER JOIN BCLS D ON D.BSPAR = 'BPSNBRH' AND D.BSCLS = C.RABRH
          LEFT OUTER JOIN BPJA E ON E.BPPYN = C.RAPYN AND E.BPJNO = C.RAJNO
        WHERE RPPYN = @RPPYN
          AND RPRDT >= @RPRDT1 AND RPRDT < @RPRDT2
          AND RPTYP LIKE @RPTYP
          AND RPAPN <> 'D'
          AND RPAPN = RPANO
          AND RPAPP = 'Y'
        ORDER BY RPNUM, RPRDT, RPREN";
        AddParam(cmd, "RPPYN", 年度專案);
        AddParam(cmd, "RPRDT1", 月初);
        AddParam(cmd, "RPRDT2", 月初.AddMonths(1));

        switch (類型)
        {
            case "請假":
                AddParam(cmd, "RPTYP", "0%");
                break;
            case "加班":
                AddParam(cmd, "RPTYP", "1%");
                break;
            case "差旅":
                AddParam(cmd, "RPTYP", "3%");
                break;
        }
        return Query.Select(cmd);
    }

    public DataTable Select報表資料_013By人員(DateTime 年月, string 人員編號, string 類型)
    {
        DateTime 月初 = 年月.AddDays(-年月.Day + 1);

        string SQL = @"
            SELECT DISTINCT A.RPREN, A.RPNUM, A.RPPYN, A.RPRDT, A.RPEDT, A.RPTYP, A.RPTCT, A.RPFTR, A.RPDOC, 
                A.RPAPP, A.RPAPD, A.RPAPU, A.RPADT, A.RPAPN, A.RPANO, A.RPAGT, A.RPRTM, A.RPETM, 
                A.RPUST, A.RPTC1, A.RPTC2, A.RPTC3, A.RPTC4, A.RPTC5, A.RPRSN, A.RPAGM, A.RPPLC,
                B.BPNME, C.RABRH, C.RAJNO, D.BSSCR AS 站別, E.BPJME AS 職稱, F.BSSCR AS 類別, 
                COALESCE(G.BPNME, H.BPNME) AS 審核人員,
                0 AS RPAC1, 0 AS RPAC2, 0 AS RPAC3, 0 AS RPAC4, 0 AS RPAC5
            FROM RPAR A
                LEFT OUTER JOIN BPSNView B ON B.BPENO = A.RPNUM
                LEFT OUTER JOIN RASN C ON A.RPPYN = C.RAPYN AND A.RPNUM = C.RANUM AND (C.RASDT <= A.RPRDT AND (C.RAEDT >= A.RPRDT OR C.RAEDT IS NULL))
                LEFT OUTER JOIN BCLS D ON D.BSPAR = 'BPSNBRH' AND D.BSCLS = C.RABRH
                LEFT OUTER JOIN BPJA E ON E.BPPYN = C.RAPYN AND E.BPJNO = C.RAJNO
                LEFT OUTER JOIN BCLS F ON F.BSPAR = 'RPARTYP' AND F.BSCLS = A.RPTYP
                LEFT OUTER JOIN BPAP G ON A.RPAPU = G.BPENO
                LEFT OUTER JOIN BPSNView H ON A.RPAPU = H.BPENO
            WHERE RPNUM = @RPNUM
                AND ( 
                       (RPRDT >= @RPRDT1 AND RPRDT < @RPRDT2) 
                    OR (RPEDT >= @RPRDT1 AND RPEDT < @RPRDT2)
                    OR (RPRDT < @RPRDT1 AND RPEDT >= @RPRDT2)
                    )
                AND RPTYP LIKE @RPTYP
                AND RPAPN <> 'D'
                AND RPAPN = RPANO
                AND RPAPP = 'Y'
                {0}
            ORDER BY RPRDT, RPREN";

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(SQL, "");
        AddParam(cmd, "RPNUM", 人員編號);
        AddParam(cmd, "RPRDT1", 月初);
        AddParam(cmd, "RPRDT2", 月初.AddMonths(1));

        switch (類型)
        {
            case "請假":
                AddParam(cmd, "RPTYP", "0%");
                break;
            case "加班":
                AddParam(cmd, "RPTYP", "1%");
                break;
            case "公差":
                AddParam(cmd, "RPTYP", "3%");
                break;
            case "差旅費":
                cmd.CommandText = String.Format(SQL, " AND RPFTR > 0 ");
                AddParam(cmd, "RPTYP", "3%");
                break;
        }
        DataTable d = Query.Select(cmd);

        if (d.Rows.Count > 0)
        {
            // 計算加班費
            ExtraWork extraWork = new ExtraWork();

            GetData calc = new GetData();
            calc.Query = Query;
            int bpsrm;
            int bpp02;
            double bpbft;
            double bpaft;
            double bphol;
            string bpovr;
            string bplve;
            string bpott;

            foreach (DataRow i in d.Rows)
            {
                // 取得該人員該專案該日期的薪資、加班費比例、加班費計算公式
                calc.GetRASN_Date_Bppyn_Bpeno_Overwork_Rate(
                    WDAC.GetDateTimeValue(i["RPRDT"]),
                    WDAC.GetStringValue(i["RPPYN"]),
                    WDAC.GetStringValue(i["RPNUM"]),
                    out bpsrm, out bpp02, out bpbft,
                    out bpaft, out bphol, out bpovr,
                    out bplve, out bpott);

                extraWork.Clear();
                extraWork.Add(
                    WDAC.GetStringValue(i["RPTYP"]),
                    WDAC.GetDateTimeValue(i["RPRDT"]),
                    WDAC.GetInt32Value(i["RPTCT"]),
                    bpsrm, bpp02, bpbft, bpaft, bphol, bpovr, bpott,
                    WDAC.GetInt32Value(i["RPTC1"]),
                    WDAC.GetInt32Value(i["RPTC2"]),
                    WDAC.GetInt32Value(i["RPTC3"]),
                    WDAC.GetInt32Value(i["RPTC4"]),
                    WDAC.GetInt32Value(i["RPTC5"]));

                i.BeginEdit();
                i["RPAC1"] = extraWork.RPTA1;
                i["RPAC2"] = extraWork.RPTA2;
                i["RPAC3"] = extraWork.RPTA3;
                i["RPAC4"] = extraWork.RPTA4;
                i["RPAC5"] = extraWork.RPTA5;
                i.EndEdit();
            }
        }

        return d;
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select出勤資料(DateTime 起日, DateTime 迄日, string 年度專案, string 人員編號)
    {
        TimeCalc timeCalc = new TimeCalc();
        RtmeDAC rtmeDao = new RtmeDAC(Query);

        // 1. 準備輸出架構
        DataTable result = new DataTable();
        result.Columns.Add("日期", typeof(DateTime));
        result.Columns.Add("人員編號", typeof(String));
        result.Columns.Add("人員姓名", typeof(String));
        result.Columns.Add("站別編號", typeof(String));
        result.Columns.Add("站別名稱", typeof(String));
        result.Columns.Add("職稱", typeof(String));
        result.Columns.Add("上班時間", typeof(String));
        result.Columns.Add("上班IP", typeof(String));
        result.Columns.Add("下班時間", typeof(String));
        result.Columns.Add("下班IP", typeof(String));
        result.Columns.Add("請假時數", typeof(Int32));
        result.Columns.Add("加班時數", typeof(Int32));
        result.Columns.Add("出差時數", typeof(Int32));
        result.Columns.Add("請假分數", typeof(Int32));
        result.Columns.Add("加班分數", typeof(Int32));
        result.Columns.Add("出差分數", typeof(Int32));
        result.Columns.Add("出差外出時間", typeof(String));
        result.Columns.Add("出差外出IP", typeof(String));
        result.Columns.Add("出差返回時間", typeof(String));
        result.Columns.Add("出差返回IP", typeof(String));
        result.Columns.Add("備註", typeof(String));

        // 2. 抓專案人員以及打卡資料
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"SELECT A.RANUM, C.BPNME, A.RABRH, G.BSRMK AS 單位, H.BPJME AS 職稱
        FROM RASN A
          INNER JOIN BPSNView C ON C.BPENO=A.RANUM
          LEFT OUTER JOIN BCLS G ON G.BSPAR='BPSNBRH' AND G.BSCLS=A.RABRH
          LEFT OUTER JOIN BPJA H ON H.BPPYN=A.RAPYN AND H.BPJNO=A.RAJNO
        WHERE A.RAPYN = @BPPYN
           AND (    (A.RASDT <= @YYMM1 AND A.RAEDT >= @YYMM2) 
                 OR (A.RASDT <= @YYMM1 AND A.RAEDT IS NULL) 
                 OR (A.RASDT <= @YYMM1 AND A.RAEDT >= @YYMM1 AND A.RAEDT <= @YYMM2)
                 OR (A.RASDT >= @YYMM1 AND A.RASDT <= @YYMM2 AND A.RAEDT >= @YYMM2)
                 OR (A.RASDT >= @YYMM1 AND A.RASDT <= @YYMM2 AND A.RAEDT IS NULL)
                 OR (A.RASDT >= @YYMM1 AND A.RASDT <= @YYMM2 AND A.RAEDT >= @YYMM1 AND A.RAEDT <= @YYMM2)  )
        GROUP BY A.RANUM, C.BPNME, A.RABRH, G.BSRMK, H.BPJME
        ORDER BY A.RANUM";
        AddParam(cmd, "BPPYN", 年度專案);
        AddParam(cmd, "YYMM1", 起日.Date);
        AddParam(cmd, "YYMM2", 迄日.Date);
        DataTable d = Query.Select(cmd);

        DateTime 日期 = 起日;

        // 抓加班時數計算方式
        BpaaDAC bpaa = new BpaaDAC(Query);
        string bpott = bpaa.GetOverTimeType(年度專案);

        // 2. 計算差勤單資料，拆到每一天

        // 2.1. 準備取當天差勤資料的 SQL
        DbCommand cmd1 = Query.NewCommand();
        cmd1.CommandText =
          //      @"SELECT RPPYN, RPNUM, RPTYP, RPRDT, RPEDT, RPRTM, RPETM, RPTCT
          //        FROM RPAR A
          //        WHERE RPPYN=@RPPYN 
          //          AND RPNUM=@RPNUM
          //          AND ((RPRDT = @YYMM1 AND RPEDT IS NULL) 
          //            OR (RPRDT <= @YYMM1 AND RPEDT >= @YYMM1))
          //          AND ((RPAPN IS NULL) 
          //            OR (RPAPN<>'D' AND RPAPN=RPANO AND RPAPP='Y'))";
          //      @"SELECT RPPYN, RPNUM, RPTYP, RPRDT, RPEDT, RPRTM, RPETM, RPTCT
          //          FROM RPAR A
          //          WHERE RPPYN=@RPPYN 
          //            AND RPNUM=@RPNUM
          //            AND ((RPRDT = @YYMM1 AND RPEDT IS NULL) 
          //              OR (RPRDT <= @YYMM1 AND RPEDT >= @YYMM1))
          //            AND ((RPAPN IS NULL) OR (RPAPN<>'D'))";
          @"SELECT RPPYN, RPNUM, RPTYP, RPRDT, RPEDT, RPRTM, RPETM, RPTCT
          FROM RPAR A
          WHERE RPPYN=@RPPYN 
            AND RPNUM=@RPNUM
            AND ((RPRDT = @YYMM1 AND RPEDT IS NULL) 
              OR (RPRDT <= @YYMM1 AND RPEDT >= @YYMM1))
            AND ((RPAPN IS NULL) OR ((RPAPN<>'D') AND (RPAPN=RPANO) AND (RPAPP<>'N')))";

        // 2.2. 準備取當天打卡資料的 SQL
        DbCommand cmd2 = Query.NewCommand();
        cmd2.CommandText =
          @"SELECT RCC01, RCC02, RCC07, RCC08, RCP01, RCP02, RCP07, RCP08 FROM RCRD
        WHERE RCDAT = @RCDAT
          AND RCUSR = @RCUSR";

        while (日期 <= 迄日)
        {
            // 2.2 計算當天資料
            foreach (DataRow r in d.Rows)
            {
                // 若有人員編號條件，於此處過濾
                if (人員編號.Length > 0)
                {
                    if (人員編號.CompareTo(r["RANUM"]) != 0)
                        continue;
                }

                // 取差勤資料，並計算
                AddParam(cmd1, "RPPYN", 年度專案);
                AddParam(cmd1, "YYMM1", 日期);
                AddParam(cmd1, "RPNUM", r["RANUM"]);
                DataTable d1 = Query.Select(cmd1);
                int 請假 = 0;
                int 加班 = 0;
                int 差旅 = 0;
                List<string> 備註 = new List<string>();

                foreach (DataRow r1 in d1.Rows)
                {
                    string RPNUM = GetStringValue(r1["RPNUM"]);
                    DateTime 差勤起日 = GetDateTimeValue(r1["RPRDT"]);
                    DateTime 差勤迄日 = GetDateTimeValue(r1["RPEDT"]);
                    string 差勤起時 = GetStringValue(r1["RPRTM"]);
                    string 差勤迄時 = GetStringValue(r1["RPETM"]);
                    string 類別 = GetStringValue(r1["RPTYP"]);

                    switch (類別.Substring(0, 1))
                    {
                        case RPAR_TYPE.T0_請假:
                            請假 += timeCalc.計算請假當日時數(RPNUM, 日期, 差勤起日, 差勤迄日, 差勤起時, 差勤迄時, 類別, bpott == "1");
                            break;
                        case RPAR_TYPE.T1_加班:
                            加班 += timeCalc.計算加班時數(RPNUM, 日期, 差勤起時, 差勤迄時, RPAR_TYPE.休息日加班(類別));
                            break;
                        case RPAR_TYPE.T3_出差:
                            差旅 += timeCalc.計算差旅當日時數(RPNUM, 日期, 差勤起日, 差勤迄日, 差勤起時, 差勤迄時);
                            break;
                    }
                }

                // 取打卡資料
                AddParam(cmd2, "RCDAT", 日期);
                AddParam(cmd2, "RCUSR", r["RANUM"]);
                DataTable d2 = Query.Select(cmd2);

                DataRow newRow = result.NewRow();
                newRow["日期"] = 日期;
                newRow["人員編號"] = r["RANUM"];
                newRow["人員姓名"] = r["BPNME"];
                newRow["站別編號"] = r["RABRH"];
                newRow["站別名稱"] = r["單位"];
                newRow["職稱"] = r["職稱"];
                if (d2.Rows.Count > 0)
                {
                    newRow["上班時間"] = d2.Rows[0]["RCC01"];
                    newRow["上班IP"] = d2.Rows[0]["RCP01"];
                    newRow["下班時間"] = d2.Rows[0]["RCC02"];
                    newRow["下班IP"] = d2.Rows[0]["RCP02"];
                    newRow["出差外出時間"] = d2.Rows[0]["RCC07"];
                    newRow["出差外出IP"] = d2.Rows[0]["RCP07"];
                    newRow["出差返回時間"] = d2.Rows[0]["RCC08"];
                    newRow["出差返回IP"] = d2.Rows[0]["RCP08"];

                    if (WDAC.GetStringValue(d2.Rows[0]["RCP01"]) == "補打卡")
                        備註.Add("補打上班卡");
                    if (WDAC.GetStringValue(d2.Rows[0]["RCP02"]) == "補打卡")
                        備註.Add("補打下班卡");
                }
                else
                {
                    newRow["上班時間"] = "";
                    newRow["上班IP"] = "";
                    newRow["下班時間"] = "";
                    newRow["下班IP"] = "";
                    newRow["出差外出時間"] = "";
                    newRow["出差外出IP"] = "";
                    newRow["出差返回時間"] = "";
                    newRow["出差返回IP"] = "";
                }

                // 取班表資料
                var btmeItem = rtmeDao.SelectBtmeDay(GetStringValue(r["RANUM"]), 日期);
                if (btmeItem != null)
                {
                    備註.Add(string.Format("值{0}{1}-{2}", btmeItem.BTNME, btmeItem.BTSTM, btmeItem.BTETM));
                }

                newRow["請假時數"] = 請假 / 60;
                newRow["請假分數"] = 請假 % 60;
                newRow["加班時數"] = 加班 / 60;
                newRow["加班分數"] = 加班 % 60;
                newRow["出差時數"] = 差旅 / 60;
                newRow["出差分數"] = 差旅 % 60;
                newRow["備註"] = string.Join("/", 備註.ToArray());
                result.Rows.Add(newRow);
            }

            日期 = 日期.AddDays(1);
        }

        return result;
    }

    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable Select出勤資料By人員(DateTime 日期, string 人員編號)
    {
        TimeCalc timeCalc = new TimeCalc();

        // 1. 抓專案人員以及打卡資料
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
          @"SELECT A.RANUM
                , C.BPNME
                , A.RAPYN
                , A.RABRH, G.BSSCR AS 單位, H.BPJME AS 職稱
                , B.RCC01, B.RCC02, B.RCP01, B.RCP02, B.RCC07, B.RCC08
                , 0 AS 請假時數, 0 AS 請假分數, 0 AS 加班時數, 0 AS 加班分數, 0 AS 出差時數, 0 AS 出差分數
                , 0 AS 請假, 0 AS 加班, 0 AS 出差
        FROM RASN A
          INNER JOIN BPSNView C ON C.BPENO=A.RANUM
          LEFT OUTER JOIN RCRD B ON B.RCUSR=A.RANUM AND B.RCDAT=@YYMM1
          LEFT OUTER JOIN BCLS G ON G.BSPAR='BPSNBRH' AND G.BSCLS=A.RABRH
          LEFT OUTER JOIN BPJA H ON H.BPPYN=A.RAPYN AND H.BPJNO=A.RAJNO
        WHERE A.RANUM = @RANUM
           AND (
                (A.RASDT <= @YYMM1 AND A.RAEDT >= @YYMM1) 
             OR (A.RASDT <= @YYMM1 AND A.RAEDT IS NULL) 
                )
        GROUP BY A.RANUM, C.BPNME, A.RAPYN, A.RABRH, G.BSSCR, H.BPJME, B.RCC01, B.RCC02, B.RCP01, B.RCP02, B.RCC07, B.RCC08
        ORDER BY A.RANUM";
        AddParam(cmd, "RANUM", 人員編號);
        AddParam(cmd, "YYMM1", 日期);
        DataTable d = Query.Select(cmd);

        // 抓加班時數計算方式
        BpaaDAC bpaa = new BpaaDAC(Query);

        // 2. 抓差勤單資料，拆到每一天
        DbCommand cmd1 = Query.NewCommand();
        cmd1.CommandText =
          @"SELECT RPPYN, RPNUM, RPTYP, RPRDT, RPEDT, RPRTM, RPETM, RPTCT
        FROM RPAR A
        WHERE RPNUM=@RPNUM
          AND ((RPRDT = @YYMM1 AND RPEDT IS NULL) 
            OR (RPRDT <= @YYMM1 AND RPEDT >= @YYMM1))
          AND ((RPAPN IS NULL) 
            OR (RPAPN<>'D' AND RPAPN=RPANO AND RPAPP='Y'))";
        AddParam(cmd1, "RPNUM", 人員編號);
        AddParam(cmd1, "YYMM1", 日期);

        foreach (DataRow r in d.Rows)
        {

            AddParam(cmd1, "RPNUM", r["RANUM"]);
            DataTable d1 = Query.Select(cmd1);
            int 請假 = 0;
            int 加班 = 0;
            int 差旅 = 0;

            foreach (DataRow r1 in d1.Rows)
            {
                string rpnum = GetStringValue(r1["RPNUM"]);
                string rppyn = GetStringValue(r1["RPPYN"]);
                string bpott = bpaa.GetOverTimeType(rppyn);
                DateTime 起日 = GetDateTimeValue(r1["RPRDT"]);
                DateTime 迄日 = GetDateTimeValue(r1["RPEDT"]);
                string 起時 = GetStringValue(r1["RPRTM"]);
                string 迄時 = GetStringValue(r1["RPETM"]);
                string 類別 = GetStringValue(r1["RPTYP"]);

                switch (類別.Substring(0, 1))
                {
                    case RPAR_TYPE.T0_請假:
                        請假 += timeCalc.計算請假當日時數(rpnum, 日期, 起日, 迄日, 起時, 迄時, 類別, bpott == "1");
                        break;
                    case RPAR_TYPE.T1_加班:
                        加班 += timeCalc.計算加班時數(rpnum, 日期, 起時, 迄時, "13,14".Contains(類別));
                        break;
                    case RPAR_TYPE.T3_出差:
                        差旅 += timeCalc.計算差旅當日時數(rpnum, 日期, 起日, 迄日, 起時, 迄時);
                        break;
                }
            }

            r.BeginEdit();
            r["請假時數"] = 請假 / 60;
            r["請假分數"] = 請假 % 60;
            r["加班時數"] = 加班 / 60;
            r["加班分數"] = 加班 % 60;
            r["出差時數"] = 差旅 / 60;
            r["出差分數"] = 差旅 % 60;
            r["請假"] = 請假;
            r["加班"] = 加班;
            r["出差"] = 差旅;
            r.EndEdit();
        }

        return d;
    }

    //public void 回填加班時數(string 單號, int 前二加班, int 後二加班, int 假日加班)
    //{
    //    DbCommand cmd = Query.NewCommand();
    //    cmd.CommandText =
    //      @"UPDATE RPAR SET
    //      RPTC1 = @RPTC1,
    //      RPTC2 = @RPTC2,
    //      RPTC3 = @RPTC3
    //    WHERE RPREN = @RPREN";
    //    AddParam(cmd, "RPTC1", 前二加班);
    //    AddParam(cmd, "RPTC2", 後二加班);
    //    AddParam(cmd, "RPTC3", 假日加班);
    //    AddParam(cmd, "RPREN", 單號);
    //    Query.ExecuteNonQuery(cmd);
    //}

    public void 回填加班費(string 單號, int RPTA1, int RPTA2, int RPTA3, int RPTA4, int RPTA5, DbTransaction tran)
    {
        DbCommand cmd = Query.NewCommand();
        if (tran != null)
        {
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
        }
        cmd.CommandText =
            @"UPDATE RPAR SET
                RPTA1 = @RPTA1,
                RPTA2 = @RPTA2,
                RPTA3 = @RPTA3,
                RPTA4 = @RPTA4,
                RPTA5 = @RPTA5,
                RPFTR = @RPFTR
            WHERE RPREN = @RPREN";
        AddParam(cmd, "RPTA1", RPTA1);
        AddParam(cmd, "RPTA2", RPTA2);
        AddParam(cmd, "RPTA3", RPTA3);
        AddParam(cmd, "RPTA4", RPTA4);
        AddParam(cmd, "RPTA5", RPTA5);
        AddParam(cmd, "RPFTR", RPTA1 + RPTA2 + RPTA3 + RPTA4 + RPTA5);
        AddParam(cmd, "RPREN", 單號);
        if (tran != null)
        {
            cmd.ExecuteNonQuery();
        }
        else
        {
            Query.ExecuteNonQuery(cmd);
        }
    }

    public void 回填缺勤扣款(string 單號, int RPFTR, DbTransaction tran)
    {
        DbCommand cmd = Query.NewCommand();
        if (tran != null) 
        {
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
        }
        cmd.CommandText =
            @"UPDATE RPAR SET
                RPFTR = @RPFTR
            WHERE RPREN = @RPREN";
        AddParam(cmd, "RPFTR", RPFTR);
        AddParam(cmd, "RPREN", 單號);
        if (tran != null)
        {
            cmd.ExecuteNonQuery();
        }
        else 
        {
            Query.ExecuteNonQuery(cmd);
        }
    }

    public bool 代理人不在(string 代理人姓名, string 代理人電郵, DateTime 起日, DateTime 迄日, string 起時, string 迄時)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
            @"SELECT COUNT(1) FROM
            (
                SELECT A.RPNUM, A.RPTYP, B.BPNME, B.BPEML,
                    CONVERT(VARCHAR(8), A.RPRDT, 112) + '-' + ISNULL(A.RPRTM, '00:00') AS START_DT,
                    CONVERT(VARCHAR(8), A.RPEDT, 112) + '-' + ISNULL(A.RPETM, '24:00') AS END_DT
                FROM RPAR A
                    LEFT JOIN BPSNView B ON A.RPNUM=B.BPENO
                WHERE A.RPRDT >= '2016/1/1' 
                    AND ((A.RPTYP >= '00' AND A.RPTYP <= '0Z') OR (A.RPTYP >= '30' AND A.RPTYP <= '3Z'))
                    AND B.BPNME = @RPAGT
                    AND B.BPEML = @RPAGM
                    AND A.RPANO <> 'D' 
                    AND A.RPAPP <> 'N'
            ) AS TMP1
            WHERE ((START_DT <= @SDT AND END_DT > @SDT) OR (START_DT < @EDT AND END_DT >= @EDT))";
        AddParam(cmd, "SDT", String.Format(WGuard1.InvariantCulture, "{0:yyyyMMdd}-{1}", 起日, 起時));
        AddParam(cmd, "EDT", String.Format(WGuard1.InvariantCulture, "{0:yyyyMMdd}-{1}", 迄日, 迄時));
        AddParam(cmd, "RPAGT", 代理人姓名);
        AddParam(cmd, "RPAGM", 代理人電郵);
        return WDAC.GetInt32Value(Query.ExecuteScalar(cmd)) > 0;
    }

    public DataTable 我是代理人的單據(string 員工姓名, string 員工電郵, DateTime 起日, DateTime 迄日, string 起時, string 迄時,
        bool check請假, bool check差勤)
    {
        string sql請假 = "A.RPTYP >= '00' AND A.RPTYP <= '0Z'";
        if (!check請假)
            sql請假 = "1=0";
        string sql差勤 = "A.RPTYP >= '30' AND A.RPTYP <= '3Z'";
        if (!check差勤)
            sql差勤 = "1=0";

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(
            @"SELECT * FROM
            (
                SELECT A.RPPYN, A.RPREN, A.RPNUM, A.RPTYP, C.BSSCR, B.BPNME, B.BPEML, B.BPMB1, B.BPMB2,
                    CONVERT(VARCHAR(8), A.RPRDT, 112) + '-' + ISNULL(A.RPRTM, '00:00') AS START_DT,
                    CONVERT(VARCHAR(8), A.RPEDT, 112) + '-' + ISNULL(A.RPETM, '24:00') AS END_DT
                FROM RPAR A
                    JOIN BPSNView B ON A.RPNUM = B.BPENO
                    JOIN BCLS C ON A.RPTYP = C.BSCLS AND C.BSPAR='RPARTYP'
                WHERE A.RPRDT >= '2016/1/1' 
                    AND (({0}) OR ({1}))
                    AND A.RPAGT = @RPAGT
                    AND A.RPAGM = @RPAGM
                    AND A.RPANO <> 'D' 
                    AND A.RPAPP <> 'N'
            ) AS TMP1
            WHERE ((START_DT <= @SDT AND END_DT > @SDT) OR (START_DT < @EDT AND END_DT >= @EDT))",
            sql請假, sql差勤);
        AddParam(cmd, "SDT", String.Format(WGuard1.InvariantCulture, "{0:yyyyMMdd}-{1}", 起日, 起時));
        AddParam(cmd, "EDT", String.Format(WGuard1.InvariantCulture, "{0:yyyyMMdd}-{1}", 迄日, 迄時));
        AddParam(cmd, "RPAGT", 員工姓名);
        AddParam(cmd, "RPAGM", 員工電郵);
        return Query.Select(cmd);
    }

    public DataTable 我是代理人的單據(string 員工姓名, string 員工電郵, DateTime 起日, DateTime 迄日, string 起時, string 迄時)
    {
        return 我是代理人的單據(員工姓名, 員工電郵, 起日, 迄日, 起時, 迄時, true, true);
    }

    public bool 檢查休息日加班(string BPENO, DateTime RPRDT, string RPREN, out string message)
    {
        message = "";

        var holiday_type = new BhrdDAC().GetDayHolidayType(RPRDT);
        if (holiday_type != HolidayType.Holiday && holiday_type != HolidayType.ElasticRest)
        {
            message = "只有例假日、休息日、彈性休假日可以申請休息日加班！";
            return false;
        }

        DateTime sun;
        DateTime sat;

        if (RPRDT.DayOfWeek == DayOfWeek.Sunday)
        {
            sun = RPRDT;
            sat = RPRDT.AddDays(-1);
        }
        else
        {
            sun = RPRDT.AddDays(1);
            sat = RPRDT;
        }

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
            @"SELECT COUNT(DISTINCT RPRDT) 
              FROM RPAR
              WHERE (RPRDT = @SAT OR RPRDT = @SUN)
                  AND RPNUM = @BPENO
                  AND (RPTYP = '13' OR RPTYP = '14')
                  AND (RPAPN IS NULL OR (RPAPN <> 'D' AND (RPAPP IS NULL OR RPAPP <> 'N')))
                  AND RPRDT <> @RPRDT";
        AddParam(cmd, "SAT", sat);
        AddParam(cmd, "SUN", sun);
        AddParam(cmd, "BPENO", BPENO);
        AddParam(cmd, "RPRDT", RPRDT);

        if (WDAC.GetInt32Value(Query.ExecuteScalar(cmd)) > 0)
        {
            message = "不可連續兩天申請休息日加班！";
            return false;
        }

        return true;
    }

    public DataTable 代理人提醒(DateTime 代理日期)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
            @"SELECT A.RPPYN, A.RPREN, A.RPNUM, A.RPTYP, A.RPAGT, A.RPAGM,
                  A.RPRDT, A.RPRTM, A.RPEDT, A.RPETM, A.RPRSN, A.RPDOC,
                  B.BPNME, B.BPEML, C.BSSCR
              FROM RPAR A
                  JOIN BPSNView B ON A.RPNUM = B.BPENO
                  JOIN BCLS C ON A.RPTYP = C.BSCLS AND C.BSPAR='RPARTYP'
              WHERE A.RPRDT = @RPRDT
                  AND ((A.RPTYP >= '00' AND A.RPTYP <= '0Z') OR (A.RPTYP >= '30' AND A.RPTYP <= '3Z')) 
                  AND A.RPAGT IS NOT NULL 
                  AND A.RPAGT <> ''
                  AND A.RPANO <> 'D' 
                  AND A.RPAPP <> 'N' ";
        AddParam(cmd, "RPRDT", 代理日期);
        return Query.Select(cmd);
    }

    public DataTable 取得督導(string 單號)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
            @"SELECT A.RPENO, B.BPNME, B.BPEML 
            FROM RPAB A
                LEFT JOIN BPSNView B ON A.RPENO = B.BPENO 
            WHERE A.RPREN <> '' AND A.RPREN IS NOT NULL AND A.RPREN = @RPREN 
                AND A.RPANO = '1' ";
        AddParam(cmd, "RPREN", 單號);
        return Query.Select(cmd);
    }

    public List<差勤日報表Item> 取得差勤日報表資料(string 年度接單編號, DateTime 起日, DateTime 迄日, string 類別)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText =
            @"SELECT DISTINCT A.RPPYN 年度接單編號, A.RPNUM 員工編號, B.BPNME 員工姓名
                , A.RPTYP 類別, C.BSSCR 類別名稱
                , A.RPRDT 起日, A.RPRTM 起時, A.RPEDT 迄日, A.RPETM 迄時
                , CAST(A.RPTCT AS INT) / 60 時數, CAST(A.RPTCT AS INT) % 60 分數  
                , D.RABRH 站別編號, E.BSSCR 站別名稱, A.RPPLC 出差地點
            FROM RPAR A
              JOIN BPSNView B ON A.RPNUM=B.BPENO
              JOIN BCLS C ON A.RPTYP=C.BSCLS AND C.BSPAR='RPARTYP'
              JOIN RASN D ON A.RPPYN=D.RAPYN AND A.RPNUM=D.RANUM 
                  AND ((D.RASDT BETWEEN @SDT AND @EDT) 
                    OR (D.RAEDT BETWEEN @SDT AND @EDT) 
                    OR (D.RASDT <= @SDT AND (D.RAEDT >= @EDT OR D.RAEDT IS NULL)))  
              JOIN BCLS E ON D.RABRH=E.BSCLS AND E.BSPAR='BPSNBRH'
            WHERE A.RPRDT > '2016/1/1'
              AND A.RPPYN = @RPPYN
              AND ((A.RPRDT BETWEEN @SDT AND @EDT) OR (A.RPEDT BETWEEN @SDT AND @EDT) OR (A.RPRDT <= @SDT AND A.RPEDT >= @EDT))
              AND A.RPANO <> 'D' 
              AND A.RPAPP <> 'N'
              AND A.RPTYP LIKE @RPTYP
            ORDER BY A.RPPYN, A.RPNUM ";
        AddParam(cmd, "RPPYN", 年度接單編號);
        AddParam(cmd, "SDT", 起日);
        AddParam(cmd, "EDT", 迄日);
        AddParam(cmd, "RPTYP", 類別 + "%");

        return Query.Select<差勤日報表Item>(cmd);
    }

    public List<補休明細Item> 取得補休明細資料(string 員工編號)
    {
        var today = DateTime.UtcNow.AddHours(8).Date;

        // 取得員工在請假日期所在專案的補休期限設定
        int otd = new GetData(Query).GetBPOTD_DATE_BPENO(today, 員工編號);

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(
          @"SELECT '補登' 類別, RBENO 員工編號, RBREN 單號, RBDAT 日期, 
                (CAST(RBTCT AS INT) - ISNULL(CAST(RBUST AS INT), 0)) / 60 可用時數, 
                (CAST(RBTCT AS INT) - ISNULL(CAST(RBUST AS INT), 0)) % 60 可用分數, 
                DATEADD(month, 6, RBDAT) 有效期限
            FROM RBSA 
            WHERE 1=1
                AND RBENO = @員工編號 
                AND RBDAT >= @起始日期                                                  -- 補休6個月之內有效
                AND RBDAT >= dbo.BPSDY(RBSA.RBENO)                                      -- 到職日之後
                AND RBDAT < @TODAY                                                      -- 今天之前
                AND (RBUST IS NULL OR RBUST<RBTCT)                                      -- 尚未使用完畢
            UNION ALL
            SELECT '加班' 類別, RPNUM 員工編號, RPREN 單號, RPRDT 日期, 
                (CAST(RPTCT AS INT) - ISNULL(CAST(RPUST AS INT), 0)) / 60 可用時數,  
                (CAST(RPTCT AS INT) - ISNULL(CAST(RPUST AS INT), 0)) % 60 可用分數, 
                DATEADD(month, 6, RPRDT) 有效期限
            FROM RPAR 
            WHERE 1=1
                AND RPNUM = @員工編號 
                AND {0} 
                AND RPRDT >= @起始日期                                                 -- 補休6個月之內有效
                AND ((RPAPN IS NOT NULL AND RPAPN <> 'D' AND RPAPN = RPANO AND RPAPP = 'Y') OR (RPAPN IS NULL))  -- 非抽單且已經簽核完畢或無須簽核的單子
                AND (RPUST IS NULL OR RPUST < RPTCT)                                   -- 尚未使用完畢
                AND RPRDT >= dbo.BPSDY(RPAR.RPNUM)                                     -- 到職日之後
                AND RPRDT < @TODAY                                                     -- 今天之前
            ORDER BY 類別, 有效期限 ", 補休類別Where);
        AddParam(cmd, "員工編號", 員工編號);
        AddParam(cmd, "起始日期", today.AddMonths(-otd));
        AddParam(cmd, "TODAY", today);
        return Query.Select<補休明細Item>(cmd);
    }


    /// <summary>
    /// 檢查輸入資料是否重複
    /// </summary>
    /// <param name="RPREN">單號</param>
    /// <param name="RPNUM">員工編號</param>
    /// <param name="RPRDT">開始日期</param>
    /// <param name="RPEDT">結束日期</param>
    /// <param name="RPRTM">開始時間</param>
    /// <param name="RPETM">結束時間</param>
    /// <returns></returns>
    public bool 加班單是否重複(string RPREN, string RPNUM, DateTime? RPRDT, DateTime? RPEDT, string RPRTM, string RPETM)
    {
        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = "SELECT COUNT(*) FROM RPAR WHERE RPREN <> @RPREN AND RPTYP LIKE '1%' AND RPAPN <> 'D' AND (RPAPP IS NULL OR RPAPP <> 'N') ";
        AddParam(cmd, "RPREN", RPREN);
        if (!string.IsNullOrEmpty(RPNUM))
        {
            cmd.CommandText += " AND RPNUM = @RPNUM ";
            AddParam(cmd, "RPNUM", RPNUM);
        }
        if (RPRDT.HasValue)
        {
            cmd.CommandText += " AND RPRDT = @RPRDT ";
            AddParam(cmd, "RPRDT", RPRDT);
        }
        if (RPEDT.HasValue)
        {
            cmd.CommandText += " AND RPEDT = @RPEDT ";
            AddParam(cmd, "RPEDT", RPEDT);
        }
        if (!string.IsNullOrEmpty(RPRTM))
        {
            cmd.CommandText += " AND RPRTM = @RPRTM ";
            AddParam(cmd, "RPRTM", RPRTM);
        }
        if (!string.IsNullOrEmpty(RPETM))
        {
            cmd.CommandText += " AND RPETM = @RPETM";
            AddParam(cmd, "RPETM", RPETM);
        }
        return WDAC.GetInt32Value(Query.ExecuteScalar(cmd)) > 0;
    }


    /// <summary>
    /// 取得當月加班時數(包含未簽核完成)
    /// </summary>
    /// <param name="年月"></param>
    /// <param name="人員編號"></param>
    /// <returns></returns>
    public int Select當月加班時數(DateTime 年月, string 人員編號, string 排除單號)
    {
        DateTime 月初 = 年月.AddDays(-年月.Day + 1);

        string SQL = @"
            SELECT ISNULL(SUM(A.RPTCT), 0)
            FROM RPAR A
            WHERE RPNUM = @RPNUM
                AND ( 
                       (RPRDT >= @RPRDT1 AND RPRDT < @RPRDT2) 
                    OR (RPEDT >= @RPRDT1 AND RPEDT < @RPRDT2)
                    OR (RPRDT < @RPRDT1 AND RPEDT >= @RPRDT2)
                    )
                AND RPTYP LIKE '1%'                    -- 加班單
                AND RPAPN <> 'D'                       -- 排除抽單
                AND (RPAPP <> 'N' OR RPAPP IS NULL)    -- 排除簽核不通過
                AND RPREN <> @EXT_RPREN                -- 排除某單號 
            ";

        DbCommand cmd = Query.NewCommand();
        cmd.CommandText = String.Format(SQL, "");
        AddParam(cmd, "RPNUM", 人員編號);
        AddParam(cmd, "RPRDT1", 月初);
        AddParam(cmd, "RPRDT2", 月初.AddMonths(1));
        AddParam(cmd, "EXT_RPREN", 排除單號);
        return WDAC.GetInt32Value(Query.ExecuteScalar(cmd));
    }

    public static string GetAttachLink(string RPREN, Page page)
    {
        var link = "";
        var allFiles = Directory.GetFiles(PublicVariable.RPARAttachPath).ToList();
        var f = allFiles.Find(p => Path.GetFileName(p).StartsWith(RPREN + "."));
        if (!String.IsNullOrEmpty(f) && File.Exists(f))
        {
            link += string.Format("<a href='{0}{1}' target='_blank'>檢視附件1</a>&nbsp;&nbsp;&nbsp;&nbsp;",
                page.ResolveClientUrl("~/UploadedPicture/RPAR_ATTACHMENT/"), Path.GetFileName(f));
        }

        f = allFiles.Find(p => Path.GetFileName(p).StartsWith(RPREN + "_2."));
        if (!String.IsNullOrEmpty(f) && File.Exists(f))
        {
            link += string.Format("<a href='{0}{1}' target='_blank'>檢視附件2</a>&nbsp;&nbsp;&nbsp;&nbsp;",
                page.ResolveClientUrl("~/UploadedPicture/RPAR_ATTACHMENT/"), Path.GetFileName(f));
        }

        f = allFiles.Find(p => Path.GetFileName(p).StartsWith(RPREN + "_3."));
        if (!String.IsNullOrEmpty(f) && File.Exists(f))
        {
            link += string.Format("<a href='{0}{1}' target='_blank'>檢視附件3</a>&nbsp;&nbsp;&nbsp;&nbsp;",
                page.ResolveClientUrl("~/UploadedPicture/RPAR_ATTACHMENT/"), Path.GetFileName(f));
        }

        if (link.Length > 0)
        {
            return link;
        }
        else
            return "無附件";
    }

    private static bool GetAttachExists(string RPREN, string fileNo)
    {
        var allFiles = Directory.GetFiles(PublicVariable.RPARAttachPath).ToList();
        return !String.IsNullOrEmpty(allFiles.Find(p => Path.GetFileName(p).StartsWith(RPREN + fileNo + ".")));
    }

    public static bool GetAttach1Exists(string RPREN)
    {
        return GetAttachExists(RPREN, "");
    }

    public static bool GetAttach2Exists(string RPREN)
    {
        return GetAttachExists(RPREN, "_2");
    }

    public static bool GetAttach3Exists(string RPREN)
    {
        return GetAttachExists(RPREN, "_3");
    }

    private static void DeleteAttach(string RPREN, string fileNo)
    {
        var allFiles = Directory.GetFiles(PublicVariable.RPARAttachPath).ToList();
        var file = allFiles.Find(p => Path.GetFileName(p).StartsWith(RPREN + fileNo + "."));
        if (!String.IsNullOrEmpty(file) && File.Exists(file))
            File.Delete(file);
    }

    public static void DeleteAttach1(string RPREN)
    {
        DeleteAttach(RPREN, "");
    }

    public static void DeleteAttach2(string RPREN)
    {
        DeleteAttach(RPREN, "_2");
    }

    public static void DeleteAttach3(string RPREN)
    {
        DeleteAttach(RPREN, "_3");
    }


    /// <summary>
    /// 打卡是否正常
    /// </summary>
    /// <param name="date">日期</param>
    /// <param name="bpeno">員工編號</param>
    /// <param name="rapyn">派駐專案</param>
    /// <param name="isDuty">是否要上班</param>
    /// <param name="rcc01">上班打卡</param>
    /// <param name="rcc02">下班打卡</param>
    /// <param name="rcc07">外出打卡</param>
    /// <param name="rcc08">返回打卡</param>
    /// <returns></returns>
    public 打卡檢查Item IsPunchcardNormal(DateTime date
        , string bpeno
        , string rapyn
        , bool isDuty
        , string rcc01
        , string rcc02
        , string rcc07
        , string rcc08)
    {
        // 不檢查打卡的
        var cmdNoCheck = Query.NewCommand(
            @"SELECT COUNT(*)
              FROM NO_PUNCH_CHECK
              WHERE CATEGORY = 'BPENO' AND VALUE = @BPENO
                 OR CATEGORY = 'RAPYN' AND VALUE = RIGHT(@RAPYN, LEN(VALUE))");
        Query.AddParam(cmdNoCheck, "BPENO", bpeno);
        Query.AddParam(cmdNoCheck, "RAPYN", rapyn);
        if (GetInt32Value(Query.ExecuteScalar(cmdNoCheck)) > 0)
        {
            return new 打卡檢查Item();
        }

        TimeCalc timeCalc = new TimeCalc();
        if (isDuty)
        {
            // 取得員工當日班表
            timeCalc.Init(bpeno, date);

            // 有打卡
            if (!string.IsNullOrEmpty(rcc01) && !string.IsNullOrEmpty(rcc02))
            {
                // 計算打卡分鐘數
                var onDutyMinutes = TimeCalc.計算分鐘數(rcc01, rcc02) - timeCalc.計算午休分鐘數(rcc01, rcc02);
                // 若有外出打卡要扣除
                if (!string.IsNullOrEmpty(rcc07) && !string.IsNullOrEmpty(rcc08))
                {
                    onDutyMinutes -= TimeCalc.計算分鐘數(rcc07, rcc08) - timeCalc.計算午休分鐘數(rcc07, rcc08);
                }
                // 如果打卡分鐘數不夠
                if (onDutyMinutes < timeCalc.上班分鐘數)
                {
                    // 加上請假出差分鐘數
                    DataTable tableRpar = Select出勤資料By人員(date, bpeno);
                    foreach (DataRow rowRpar in tableRpar.Rows)
                    {
                        onDutyMinutes += WDAC.GetInt32Value(rowRpar["請假"]);
                        onDutyMinutes += WDAC.GetInt32Value(rowRpar["出差"]);
                    }
                    // 若分鐘數還不夠，列入發郵件
                    if (onDutyMinutes < timeCalc.上班分鐘數)
                    {
                        return new 打卡檢查Item(false, 打卡檢查Item.時數不足);
                    }
                }
            }
            // 沒有打卡
            else
            {
                // 取得請假與差旅單
                DataTable tableRpar = Select出勤資料By人員(date, bpeno);
                var offDutyMinutes = 0;
                foreach (DataRow rowRpar in tableRpar.Rows)
                {
                    offDutyMinutes += WDAC.GetInt32Value(rowRpar["請假"]);
                    offDutyMinutes += WDAC.GetInt32Value(rowRpar["出差"]);
                }
                // 若分鐘數還不夠，列入發郵件
                if (offDutyMinutes < timeCalc.上班分鐘數)
                {
                    return new 打卡檢查Item(false, 打卡檢查Item.時數不足);
                }
            }
        }

        // 檢查是否連續七天打卡
        RcrdDAC rcrdDao = new RcrdDAC(Query);
        if (rcrdDao.PunchDaysIn7Days(date, bpeno, true) >= 7)
            return new 打卡檢查Item(false, 打卡檢查Item.打卡異常);

        return new 打卡檢查Item();
    }

    private const string RparGridColumns =
        @"TRDAT, TRMOD, TRUSR, RPREN, RPNUM, RAITM, RPCNM, RPPYN, RPRDT, RPEDT, RPTYP, FLOOR(RPTCT / 60) AS RPTCT, RPFTR, RPDOC,
             APPNO, RPAPP, RPAPD, RPAPU, RPADT, RPAPN, RPANO, RPAGT, RPRTM, RPETM, RPUST, RPTC1, RPTC2, RPTC3,
             RPRSN, RPAGM, ISNULL(RPTCT - FLOOR(RPTCT / 60) * 60, 0) AS RPTMT";

    private const string RparGridWhere = " WHERE ((RPAPN IS NULL) OR ((RPAPN<>'D') AND (RPAPN=RPANO))) ";

    /// <summary>
    /// 差勤紀錄 Grid 分頁查詢
    /// </summary>
    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable SelectPage(int startRowIndex, int maximumRows, string RPPYN, string RPNUM1, string RPNUM2, string RPRDT1, string RPRDT2, string rparType)
    {
        DbCommand cmd = Query.NewCommand();

        StringBuilder filter = new StringBuilder();
        BuildRparGridFilter(filter, cmd, RPPYN, RPNUM1, RPNUM2, RPRDT1, RPRDT2, rparType);

        cmd.CommandText = String.Format(
            @"SELECT * FROM
              (
                SELECT {0}, ROW_NUMBER() OVER (ORDER BY RPREN) AS ROWID
                FROM RPAR {1} {2}
              ) AS TMP
              WHERE ROWID BETWEEN @STARTROWINDEX + 1 AND @STARTROWINDEX + @MAXIMUMROWS
              ORDER BY ROWID",
            RparGridColumns, RparGridWhere, filter.ToString());
        cmd.Parameters.Add(Query.NewParameter("STARTROWINDEX", startRowIndex));
        cmd.Parameters.Add(Query.NewParameter("MAXIMUMROWS", maximumRows));

        return Query.Select(cmd);
    }

    /// <summary>
    /// 差勤紀錄 Grid 查詢筆數
    /// </summary>
    [DataObjectMethod(DataObjectMethodType.Select)]
    public int SelectCount(string RPPYN, string RPNUM1, string RPNUM2, string RPRDT1, string RPRDT2, string rparType)
    {
        DbCommand cmd = Query.NewCommand();

        StringBuilder filter = new StringBuilder();
        BuildRparGridFilter(filter, cmd, RPPYN, RPNUM1, RPNUM2, RPRDT1, RPRDT2, rparType);

        cmd.CommandText = String.Format("SELECT COUNT(*) FROM RPAR {0} {1}", RparGridWhere, filter.ToString());
        return WDAC.GetInt32Value(Query.ExecuteScalar(cmd));
    }

    private void BuildRparGridFilter(StringBuilder sb, DbCommand cmd, string RPPYN, string RPNUM1, string RPNUM2, string RPRDT1, string RPRDT2, string rparType)
    {
        switch (rparType)
        {
            case "0":
                sb.Append(" AND RPTYP LIKE '0%' ");
                break;
            case "1":
                sb.Append(" AND RPTYP LIKE '1%' ");
                break;
            case "21":
                sb.Append(" AND RPTYP = '21' ");
                break;
            case "22":
                sb.Append(" AND RPTYP = '22' ");
                break;
            case "3":
                sb.Append(" AND RPTYP LIKE '3%' ");
                break;
        }

        if (!string.IsNullOrEmpty(RPPYN))
        {
            sb.Append(" AND RPPYN = @RPPYN1 ");
            cmd.Parameters.Add(Query.NewParameter("RPPYN1", RPPYN));
        }

        AppendRparRange(sb, cmd, "RPNUM", RPNUM1, RPNUM2, true);
        AppendRparRange(sb, cmd, "RPRDT", RPRDT1, RPRDT2, false);
    }

    private void AppendRparRange(StringBuilder sb, DbCommand cmd, string field, string value1, string value2, bool like)
    {
        bool has1 = !string.IsNullOrEmpty(value1);
        bool has2 = !string.IsNullOrEmpty(value2);

        if (has1 && has2)
        {
            sb.AppendFormat(" AND {0} >= @{0}1 AND {0} <= @{0}2 ", field);
            cmd.Parameters.Add(Query.NewParameter(field + "1", value1));
            cmd.Parameters.Add(Query.NewParameter(field + "2", value2));
        }
        else if (has1)
        {
            if (like)
            {
                sb.AppendFormat(" AND {0} LIKE @{0}1 ", field);
                cmd.Parameters.Add(Query.NewParameter(field + "1", value1 + "%"));
            }
            else
            {
                sb.AppendFormat(" AND {0} >= @{0}1 ", field);
                cmd.Parameters.Add(Query.NewParameter(field + "1", value1));
            }
        }
        else if (has2)
        {
            if (like)
            {
                sb.AppendFormat(" AND {0} LIKE @{0}2 ", field);
                cmd.Parameters.Add(Query.NewParameter(field + "2", value2 + "%"));
            }
            else
            {
                sb.AppendFormat(" AND {0} <= @{0}2 ", field);
                cmd.Parameters.Add(Query.NewParameter(field + "2", value2));
            }
        }
    }

    /// <summary>
    /// 差勤紀錄 Grid 分頁查詢 (員工本人)
    /// </summary>
    [DataObjectMethod(DataObjectMethodType.Select)]
    public DataTable SelectWorkerPage(int startRowIndex, int maximumRows, string RPNUM_FIXED, string RPRDT1, string RPRDT2, string rparType)
    {
        DbCommand cmd = Query.NewCommand();

        StringBuilder filter = new StringBuilder();
        BuildWorkerGridFilter(filter, cmd, RPNUM_FIXED, RPRDT1, RPRDT2, rparType);

        cmd.CommandText = String.Format(
            @"SELECT * FROM
              (
                SELECT {0}, ROW_NUMBER() OVER (ORDER BY RPREN) AS ROWID
                FROM RPAR {1}
              ) AS TMP
              WHERE ROWID BETWEEN @STARTROWINDEX + 1 AND @STARTROWINDEX + @MAXIMUMROWS
              ORDER BY ROWID",
            RparGridColumns, filter.ToString());
        cmd.Parameters.Add(Query.NewParameter("STARTROWINDEX", startRowIndex));
        cmd.Parameters.Add(Query.NewParameter("MAXIMUMROWS", maximumRows));

        return Query.Select(cmd);
    }

    /// <summary>
    /// 差勤紀錄 Grid 查詢筆數 (員工本人)
    /// </summary>
    [DataObjectMethod(DataObjectMethodType.Select)]
    public int SelectWorkerCount(string RPNUM_FIXED, string RPRDT1, string RPRDT2, string rparType)
    {
        DbCommand cmd = Query.NewCommand();

        StringBuilder filter = new StringBuilder();
        BuildWorkerGridFilter(filter, cmd, RPNUM_FIXED, RPRDT1, RPRDT2, rparType);

        cmd.CommandText = String.Format("SELECT COUNT(*) FROM RPAR {0}", filter.ToString());
        return WDAC.GetInt32Value(Query.ExecuteScalar(cmd));
    }

    private void BuildWorkerGridFilter(StringBuilder sb, DbCommand cmd, string RPNUM_FIXED, string RPRDT1, string RPRDT2, string rparType)
    {
        sb.Append(" WHERE RPNUM = @RPNUM_FIXED ");
        cmd.Parameters.Add(Query.NewParameter("RPNUM_FIXED", RPNUM_FIXED));

        switch (rparType)
        {
            case "0":
                sb.Append(" AND RPTYP LIKE '0%' AND RPADT IS NOT NULL ");
                break;
            case "1":
                sb.Append(" AND RPTYP LIKE '1%' AND RPADT IS NOT NULL ");
                break;
            case "3":
                sb.Append(" AND RPTYP LIKE '3%' AND RPADT IS NOT NULL ");
                break;
        }

        AppendRparRange(sb, cmd, "RPRDT", RPRDT1, RPRDT2, false);
    }
}



public class 差勤日報表Item
{
    public string 年度接單編號 { get; set; }
    public string 員工編號 { get; set; }
    public string 員工姓名 { get; set; }
    public string 類別 { get; set; }
    public string 類別名稱 { get; set; }
    public DateTime 起日 { get; set; }
    public string 起時 { get; set; }
    public DateTime 迄日 { get; set; }
    public string 迄時 { get; set; }
    public double 時數 { get; set; }
    public double 分數 { get; set; }
    public string 站別編號 { get; set; }
    public string 站別名稱 { get; set; }
    public string 出差地點 { get; set; }
}

public class 補休明細Item
{
    public string 類別 { get; set; }
    public string 員工編號 { get; set; }
    public string 單號 { get; set; }
    public DateTime 日期 { get; set; }
    public double 可用時數 { get; set; }
    public double 可用分數 { get; set; }
    public DateTime 有效期限 { get; set; }
}

public class 打卡檢查Item 
{
    public bool 正常 { get; set; }
    public string 異常訊息 { get; set; }

    public const string 時數不足 = "打卡時數 + 請假時數 + 差勤時數不足當天應上班時數";
    public const string 打卡異常 = "連續 7 天打卡";

    public 打卡檢查Item() 
    {
        this.正常 = true;
        this.異常訊息 = String.Empty;
    }

    public 打卡檢查Item(bool 正常, string 異常訊息) : this() 
    {
        this.正常 = 正常;
        this.異常訊息 = 異常訊息;
    }
}