工事管理システム製品化対応

	HomePageURL varchar(120) DEFAULT '' COMMENT '?z?[???y?[?WURL',

	'',

<?xml version="1.0" encoding="utf-8"?>

<configuration>

  <startup>

    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

  </startup>

</configuration>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ProcessManagement.Common

{

    /// <summary>

    /// システムバージョン定義クラス

    /// </summary>

    public static class CommonVersion

    {

        /// <summary>

        /// 本体バージョン

        /// </summary>

        public static int s_SystemVersion = 0;

    }

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Collections;

using System.Diagnostics;

using log4net;

using log4net.Appender;

using log4net.Repository.Hierarchy;

using ProcessManagement.Common;

using ProcessManagement.DB.IOAccess;

using ProcessManagement.DataModel;

using ProcessManagement.Forms.DataEntry;

//*----------------------- 工事詳細台帳データ変更クラス -----------------------*

//  2016/05/31  Ver1.0.0.0      Create Source           

//

//

//

//*----------------------------------------------------------------------------*

namespace ProcessManagement.Common

{

    /// <summary>

    /// 工事詳細台帳データ変更クラス

    /// </summary>

    public static class ClsChangeLedgerData

    {

        #region ログ定義

        /// <summary>

        /// log4netログを使用する

        /// </summary>

        private static readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        #endregion

        #region 定数

        #endregion

        #region 変数

        /// <summary>

        /// 工事施工台帳支払い実績先頭カラム数

        /// </summary>

        private static int m_LedgerColumnCount = 0;

        #endregion

        #region 工事詳細台帳再計算処理（総支払額・粗利・給与・純利益が対象）

        /// <summary>

        /// 工事詳細台帳再計算処理（総支払額・粗利・給与・純利益が対象）

        /// </summary>

        /// <param name="ConstrCode"></param>

        private static bool LedgerRecalculate(IOConstructionLedgerExcute LedgerExcuteDB, List<int> ConstrCodeList)

        {

            try

            {

                string strSQL = string.Empty;

                bool bRet = true;

                foreach (int ConstrCode in ConstrCodeList)

                {

                    // 工事台帳実行データよりグループごとの合計金額を取得する

                    strSQL = "SELECT GROUPCOUNT, SUM(PAYMENTAMOUNT)";

                    strSQL += " FROM CONSTRUCTIONLEDGEREXCUTE";

                    strSQL += string.Format(" WHERE CONSTRUCTIONCODE = {0}", ConstrCode);

                    strSQL += " GROUP BY GROUPCOUNT";

                    strSQL += " ORDER BY GROUPCOUNT";

                    ArrayList InData = new ArrayList();

                    if (!LedgerExcuteDB.ExecuteReader(strSQL, ref InData, false)) continue;

                    // データ無は次のデータ

                    if (InData.Count == 0) continue;

                    // 対象データ取得

                    List<int> GroupCodeList = new List<int>();

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.Expenses);               // 1:経費

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.ConstructionCosts);      // 2:施工費

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.TransportationCosts);    // 3:交通費（通行料・電車代）

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.PurchaseCosts);          // 4:購入品

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.VehicleLeaseFee);        // 5:車両リース代

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.ParkingCosts);           // 6:駐車場・資材置き場

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.RoomChargeCosts);        // 7:宿泊費

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.DisposeCosts);           // 8:処分費等

                    int Payment = CalcGetTotal(InData, GroupCodeList);                              // ----- 支払額

                    GroupCodeList.Clear();

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.Instructor);             // 9:指導員給料行

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.Assistant);              // 10:副担当者給料行

                    int PExpenses = CalcGetTotal(InData, GroupCodeList);                            // ----- 人件費

                    GroupCodeList.Clear();

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.Payroll);                // 11:担当者給料行

                    int Allowance = CalcGetTotal(InData, GroupCodeList);                            // ----- 給与

                    GroupCodeList.Clear();

                    GroupCodeList.Add((int)FrmConstructionLedger.DataGroup.BillingAmount);          // 14:請求金額

                    int Billing = CalcGetTotal(InData, GroupCodeList);                              // ----- 請求額

                    // ----- 工事詳細台帳更新

                    strSQL = "UPDATE CONSTRUCTIONLEDGER SET";

                    strSQL += string.Format(" TOTALPAYMENT = {0}", Payment);

                    strSQL += string.Format(" , GROSSPROFIT = {0}", (Billing - Payment));

                    strSQL += string.Format(" , Allowance = {0}", Allowance);

                    strSQL += string.Format(" , NETPROFIT = {0}", (Billing - (Payment + Allowance + PExpenses)));

                    strSQL += string.Format(" WHERE CONSTRUCTIONCODE = {0}", ConstrCode);

                    if (!LedgerExcuteDB.ExecuteNonQuery(strSQL, false))

                    {

                        bRet = false;

                        break;

                    }

                }

                return bRet;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 配列リストより指定された合計を取得する

        /// <summary>

        /// 配列リストより指定された合計を取得する

        /// </summary>

        private static int CalcGetTotal(ArrayList InData, List<int> GroupCodeList)

        {

            try

            {

                int iRetVal = 0;

                int GrpNo = -1;

                foreach (int GroupCode in GroupCodeList)

                {

                    foreach (object[] CurRec in InData)

                    {

                        GrpNo = CommonMotions.cnvInt(CurRec[0]);

                        if (GroupCode != GrpNo) continue;

                        iRetVal += CommonMotions.cnvInt(CurRec[1]);

                    }

                }

                return iRetVal;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 工事詳細台帳より支払金額グリッドの先頭カラム数を取得する

        /// <summary>

        /// 工事詳細台帳より支払金額グリッドの先頭カラム数を取得する

        /// </summary>

        private static void GetLedgerColumnCount()

        {

            try

            {

                m_LedgerColumnCount = Enum.GetNames(typeof(FrmConstructionLedger.GridColumn)).Length - 1;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

            }

        }

        #endregion

        #region 工事詳細台帳データに対象行の支払い給与を計算する

        /// <summary>

        /// 工事詳細台帳データに対象行の支払い給与を計算する

        /// </summary>

        /// <param name="ConstrCode">工事番号</param>

        /// <param name="TargetDate">対象日</param>

        /// <param name="bSetFlag">月一括セットフラグ</param>

        /// <returns></returns>

        public static bool CalculatePayment(List<ConstructionLedger> LedgerList)

        {

            IOConstructionLedgerDetail LedgerDeDB = new IOConstructionLedgerDetail();

            IOConstructionLedgerExcute LedgerExDB = new IOConstructionLedgerExcute();

            IOMPersonInCharge PersonDB = new IOMPersonInCharge();

            try

            {

                bool bret = true;

                List<int> ConstrCodeList = new List<int>();

                LedgerDeDB.connect(); LedgerDeDB.beginTran();

                LedgerExDB.connect(); LedgerExDB.beginTran();

                PersonDB.connect(); PersonDB.beginTran();

                foreach (ConstructionLedger LedgerRec in LedgerList)

                {

                    // 工事詳細台帳明細データ取得

                    List<ConstructionLedgerDetail> DetailList = new List<ConstructionLedgerDetail>();

                    string DetailSQL = LedgerDeDB.CreatePrimarykeyString(LedgerRec.ConstructionCode);

                    DetailSQL += string.Format(" AND OperatingFlg = {0}", (int)CommonDefine.SalaryOperateKind.Oparateing);  // 対応中フラグ

                    DetailSQL += string.Format(" AND SALARYFLG != {0}", (int)CommonDefine.SalaryDevision.Noting);           // 給与振分区分

                    DetailSQL += string.Format(" AND GROUPCOUNT IN ({0},{1},{2})",

                                                                    (int)FrmConstructionLedger.DataGroup.Instructor,        // 指導員給料

                                                                    (int)FrmConstructionLedger.DataGroup.Assistant,         // 副担当者給料

                                                                    (int)FrmConstructionLedger.DataGroup.Payroll);          // 担当者給料行

                    if (!LedgerDeDB.SelectAction(DetailSQL, ref DetailList, false) || DetailList.Count == 0) continue;

                    DateTime TargetDate = DateTime.Now.Date;

                    // 対象月より書込みカラム位置を取得する

                    int ColPoint = CalcTargetMonthToColumn(LedgerRec.ConstructionStart, TargetDate);

                    foreach (ConstructionLedgerDetail CurRec in DetailList)

                    {

                        // コードが担当者ではない場合は処理しない

                        if (CurRec.CompanyType != (int)CommonDefine.CodeDataType.Person) continue;

                        // コードがない場合は処理しない

                        if (CurRec.CompanyCode == 0) continue;

                        // 施工管理中担当者ではない場合は処理しない

                        if (CurRec.OperatingFlg == (int)CommonDefine.SalaryOperateKind.Complate) continue;

                        //if (LedgerRec.ConstructionCode == 2016043601)

                        //{

                        //    Debug.WriteLine("stop");

                        //}

                        // セットする金額を計算する

                        switch (CurRec.SalaryFlg)

                        {

                            case (int)CommonDefine.SalaryDevision.All:          // 全日振分

                                bret = CalcSalaryDevisionAll(LedgerExDB, PersonDB, LedgerRec, CurRec, TargetDate.Date, ColPoint);

                                break;

                            case (int)CommonDefine.SalaryDevision.Noting:       // 振分無

                                bret = CalcSalaryDevisionNoting(LedgerExDB, CurRec, TargetDate.Date, ColPoint);

                                break;

                            case (int)CommonDefine.SalaryDevision.DaysInput:    // 日数入力

                                bret = CalcSalaryDevisionDaysInput(LedgerExDB, PersonDB, LedgerRec, CurRec);

                                break;

                            default:

                                break;

                        }

                    }

                    ConstrCodeList.Add(LedgerRec.ConstructionCode);

                }

                if (bret)

                {

                    // 工事台帳更新

                    bret = LedgerRecalculate(LedgerExDB, ConstrCodeList);

                }

                // エラー時ロールバック

                if (!bret) LedgerExDB.rollback();

                // DB Commit

                LedgerExDB.commit();

                return bret;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

            finally

            {

                LedgerDeDB.close(); LedgerDeDB = null;

                LedgerExDB.close(); LedgerExDB = null;

                PersonDB.close(); PersonDB = null;

            }

        }

        #endregion

        #region 全日振分時の給与書込み

        /// <summary>

        /// 全日振分時の給与書込み

        /// </summary>

        private static bool CalcSalaryDevisionAll(IOConstructionLedgerExcute LedgerExDB,

                                                    IOMPersonInCharge PersonDB,

                                                    ConstructionLedger LedgerRec,

                                                    ConstructionLedgerDetail CurRec,

                                                    DateTime CalcEndtDate,

                                                    int ColPoint)

        {

            try

            {

                DateTime StartDate = DateTime.Now;

                DateTime CompDate = DateTime.Now;

                // ----- 計算開始日取得

                if (LedgerRec.ConstructionStart.Year == CalcEndtDate.Year

                    && LedgerRec.ConstructionStart.Month == CalcEndtDate.Month)

                {   // 対象期間の開始が当月の場合は工事開始日を開始にする

                    StartDate = LedgerRec.ConstructionStart;

                }

                else

                {   // 違う場合は月初

                    StartDate = DateTime.Parse(string.Format("{0}/{1}/{2}", CalcEndtDate.Year, CalcEndtDate.Month, 1));

                }

                // ----- 計算終了日取得

                if (LedgerRec.ConstructionEnd.Year == CalcEndtDate.Year

                    && LedgerRec.ConstructionEnd.Month == CalcEndtDate.Month)

                {   // 対象期間の終了が当月の場合は工事終了日を終了にする

                    CompDate = LedgerRec.ConstructionEnd;

                }

                else

                {   // 違う場合は終了日

                    CompDate = CalcEndtDate;

                }

                int SumSaraly = 0;

                // 月末日より月日数を取得する

                int MonthDayCnt = DateTimeUtil.EndOfMonth(CalcEndtDate).Day;

                // 経過日数を取得する

                TimeSpan ts = CompDate - StartDate;

                // 支払給与計算

                switch (CurRec.GroupCount)

                {

                    case (int)FrmConstructionLedger.DataGroup.Instructor:       // 指導員給料

                        SumSaraly = CommonMotions.cnvRound((double)CommonDefine.InstructorMonthryCost / MonthDayCnt);

                        SumSaraly *= (ts.Days + 1);

                        break;

                    case (int)FrmConstructionLedger.DataGroup.Assistant:        // 副担当者給料

                        SumSaraly = CommonMotions.cnvRound((double)CommonDefine.AssistantMonthryCost / MonthDayCnt);

                        SumSaraly *= (ts.Days + 1);

                        break;

                    case (int)FrmConstructionLedger.DataGroup.Payroll:          // 担当者給料行

                        // 範囲給与取得

                        SumSaraly = CommonMotions.CalcElapsedSalary(PersonDB, StartDate, CompDate, CurRec.CompanyCode);

                        break;

                }

                // 実行データのキー部年月日は対象月の1日

                DateTime ParaDate = new DateTime(CalcEndtDate.Year, CalcEndtDate.Month, 1);

                // 支払いデータ書込み

                if (!AddOrSetSalary(LedgerExDB

                                , CurRec.ConstructionCode, CurRec.GroupCount, CurRec.LineCount, ColPoint, SumSaraly, ParaDate))

                {

                    return false;

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 振分無時の給与書込み

        /// <summary>

        /// 振分無時の給与書込み

        /// </summary>

        private static bool CalcSalaryDevisionNoting(IOConstructionLedgerExcute LedgerExDB,

                                                    ConstructionLedgerDetail CurRec,

                                                    DateTime CalcEndtDate,

                                                    int ColPoint)

        {

            try

            {

                // 実行データのキー部年月日は対象月の1日

                DateTime ParaDate = new DateTime(CalcEndtDate.Year, CalcEndtDate.Month, 1);

                // 支払いデータ書込み

                if (!AddOrSetSalary(LedgerExDB

                                , CurRec.ConstructionCode, CurRec.GroupCount, CurRec.LineCount, ColPoint, 0, ParaDate))

                {

                    return false;

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 日付指定時の給与書込み

        /// <summary>

        /// 日付指定時の給与書込み

        /// </summary>

        private static bool CalcSalaryDevisionDaysInput(IOConstructionLedgerExcute LedgerExDB,

                                                        IOMPersonInCharge PersonDB,

                                                        ConstructionLedger LedgerRec,

                                                        ConstructionLedgerDetail CurRec)

        {

            try

            {

                int OneDaySalary = 0;

                // 月末日より月日数を取得する

                int MonthDayCnt = DateTimeUtil.EndOfMonth(LedgerRec.ConstructionStart).Day;

                // 支払給与計算

                switch (CurRec.GroupCount)

                {

                    case (int)FrmConstructionLedger.DataGroup.Instructor:       // 指導員給料

                        OneDaySalary = CommonMotions.cnvRound((double)CommonDefine.InstructorMonthryCost / MonthDayCnt);

                        OneDaySalary *= CurRec.SalaryDays;

                        break;

                    case (int)FrmConstructionLedger.DataGroup.Assistant:        // 副担当者給料

                        OneDaySalary = CommonMotions.cnvRound((double)CommonDefine.AssistantMonthryCost / MonthDayCnt);

                        OneDaySalary *= CurRec.SalaryDays;

                        break;

                    case (int)FrmConstructionLedger.DataGroup.Payroll:          // 担当者給料行

                        // 給与取得

                        OneDaySalary = CommonMotions.CalcElapsedSalary(PersonDB, LedgerRec.ConstructionStart, LedgerRec.ConstructionStart, CurRec.CompanyCode);

                        OneDaySalary *= CurRec.SalaryDays;

                        break;

                }

                // 実行データのキー部年月日は開始月の1日

                DateTime ParaDate = new DateTime(LedgerRec.ConstructionStart.Year, LedgerRec.ConstructionStart.Month, 1);

                // 台帳カラム位置

                int Columncnt = Enum.GetNames(typeof(FrmConstructionLedger.GridColumn)).Length - 1;

                // 支払いデータ書込み

                if (!AddOrSetSalary(LedgerExDB

                                , CurRec.ConstructionCode, CurRec.GroupCount, CurRec.LineCount, Columncnt, OneDaySalary, ParaDate))

                {

                    return false;

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 日次処理での日当の加算を判定する

        /// <summary>

        /// 日次処理での日当の加算を判定する

        /// </summary>

        /// <param name="CurRec"></param>

        /// <returns></returns>

        private static bool CheckPaymentValue(ConstructionLedgerDetail CurRec)

        {

            IOConstructionLedgerExcute ExcuteDB = new IOConstructionLedgerExcute();

            try

            {

                // 支払いデータより合計金額を取得する

                ArrayList arList = new ArrayList();

                string ExcuteSQL = "SELECT SUM(PAYMENTAMOUNT) FROM CONSTRUCTIONLEDGEREXCUTE";

                ExcuteSQL += string.Format(" WHERE CONSTRUCTIONCODE = {0}", CurRec.ConstructionCode);

                ExcuteSQL += string.Format(" AND GROUPCOUNT = {0}", CurRec.GroupCount);

                ExcuteSQL += string.Format(" AND LINECOUNT = {0}", CurRec.LineCount);

                if (!ExcuteDB.ExecuteReader(ExcuteSQL, ref arList) || arList.Count == 0) return false;

                object[] wrkobj = (object[])arList[0];

                int TotalVal = CommonMotions.cnvInt(wrkobj[0]);

                bool bRet = false;

                if (TotalVal < CurRec.ExecutionAmount) bRet = true;

                return bRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 詳細台帳に指定金額を設定するか足しこむ

        /// <summary>

        /// 詳細台帳に指定金額を設定するか足しこむ

        /// </summary>

        private static bool AddOrSetSalary(IOConstructionLedgerExcute LedgerExDB

                                    , int ConstrCode, int GroupCount, int LineCount, int ColumnCount

                                    , int DaySalary, DateTime ColumnDate)

        {

            try

            {

                // キー作成

                string strSQL = LedgerExDB.CreatePrimarykeyString(ConstrCode, GroupCount, LineCount, ColumnCount);

                strSQL += string.Format(" AND DATE(TargetMonth) = STR_TO_DATE('{0}','%Y/%m/%d')", ColumnDate.ToShortDateString());

                // データ読込み

                List<ConstructionLedgerExcute> LedgerExDBList = new List<ConstructionLedgerExcute>();

                ConstructionLedgerExcute LedgerExDBRec = new ConstructionLedgerExcute();

                bool ReadData = LedgerExDB.SelectAction(strSQL, ref LedgerExDBList, false);

                if (!ReadData || LedgerExDBList.Count == 0)

                {

                    LedgerExDBRec.ConstructionCode = ConstrCode;	// 工事コード

                    LedgerExDBRec.GroupCount = GroupCount;          // グループ番号

                    LedgerExDBRec.LineCount = LineCount;            // 行番号

                    LedgerExDBRec.ColumnCount = ColumnCount;        // 列番号

                    LedgerExDBRec.PaymentAmount = DaySalary;        // 支払金額

                    LedgerExDBRec.TargetMonth = ColumnDate;         // 対象年月

                    // データ作成

                    if (!LedgerExDB.InsertAction(LedgerExDBRec, false)) return false;

                    return true;

                }

                // データ更新

                if (!LedgerExDB.UpdateFeild(ConstrCode, GroupCount, LineCount, ColumnCount

                                            , (int)IOConstructionLedgerExcute.TableColumn.PaymentAmount, DaySalary, false)) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 対象年月から工事詳細台帳のグリッドカラム位置を算出する

        /// <summary>

        /// 対象年月から工事詳細台帳のグリッドカラム位置を算出する

        /// </summary>

        /// <param name="TargetMonth"></param>

        /// <returns></returns>

        public static int CalcTargetMonthToColumn(DateTime StartDate, DateTime TargetMonth)

        {

            int Columncnt = Enum.GetNames(typeof(FrmConstructionLedger.GridColumn)).Length - 1;

            try

            {

                // 処理対象年月日を対象月月初日に変換する

                DateTime NowDates = DateTimeUtil.BeginOfMonth(TargetMonth);

                // 開始年月日を開始年月月初日に変換する

                DateTime StartMonth = DateTimeUtil.BeginOfMonth(StartDate);

                // 経過月数を取得する

                //TimeSpan ts = NowDates - StartDate;

                //int DiffMonth = ts.GetTimeSpanMonths();

                int DiffMonth = (TargetMonth.Month + (TargetMonth.Year - StartDate.Year) * 12) - StartDate.Month;

                // 列番号取得

                Columncnt += DiffMonth;

                return Columncnt;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return Columncnt;

            }

        }

        #endregion

    }

}

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

using log4net;

using log4net.Appender;

using log4net.Repository.Hierarchy;

using ProcessManagement.Common;

using ProcessManagement.DB.IOAccess;

using ProcessManagement.DataModel;

namespace ProcessManagement.Common

{

    /// <summary>

    /// システム初回起動時処理クラス

    /// </summary>

    public class ClsSystemOnceExecute

    {

        #region 使用定義

        //log4netログを使用する

        private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        #endregion

        #region 定数

        /// <summary>

        /// 非受注へ移す期間（受注できずに見積提出日より以下の日数を過ぎれば非受注へ移動）

        /// </summary>

        private const int s_NonOrderDay = 93;

        /// <summary>

        /// 非受注時メッセージ

        /// </summary>

        private const string s_NonOrderComment = "受注できずに見積提出日より{0}日を過ぎましたので非受注とします。";

        #endregion

        #region 変数

        /// <summary>

        /// 初期化処理成否フラグ

        /// </summary>

        private bool m_bExecuteFlg = true;

        /// <summary>

        /// 状態毎期限マスタリスト

        /// </summary>

        private List<TermMasterList> SystemOnceExecuteTermMstList = new List<TermMasterList>();

        /// <summary>

        /// 最終起動日

        /// </summary>

        DateTime m_lastsessionDate = DateTime.MinValue;

        #endregion

        #region コンストラクタ

        public ClsSystemOnceExecute()

        {

            // チェック項目取得

            if (!GetTermList())

            {

                m_bExecuteFlg = false;

            }

        }

        #endregion

        #region チェックプロセス

        /// <summary>

        /// 初期起動チェックプロセス

        /// </summary>

        /// <returns></returns>

        public void FirstExecute()

        {

            bool ProcessFlg = true;

            try

            {

                // 初期化に失敗したら処理しない

                if (!m_bExecuteFlg) return;

                // 本日の初回起動がされている場合は処理しない

                if (!ExecuteCheck(ref m_lastsessionDate)) return;

                // 更新済みにするために日付の更新

                if (!(ProcessFlg = UpDateTargetDate(DateTime.Now))) return;

                // ----- データチェック

                // 資材返却期限のチェックを行う

                if (!(ProcessFlg = MaterialLimitCheck(m_lastsessionDate))) return;

                // 日付の期限チェックを行う

                if(!(ProcessFlg = SubmittedDateCheck(m_lastsessionDate))) return;

                // 見積有効期限切れを非受注へ移行する

                if (!(ProcessFlg = ChangeNonOrdersData())) return;

                // 開始期日がきた給与を適用する

                if (!(ProcessFlg = SetNewPayrollCheck())) return;

                // 工事詳細台帳の給与を加算する

                if (!(ProcessFlg = CalculateDaysSalary(m_lastsessionDate))) return;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

            }

            finally

            {

                // エラー時は元の日付に更新

                if (!ProcessFlg) UpDateTargetDate(m_lastsessionDate);

            }

        }

        #endregion

        #region 日付チェック

        /// <summary>

        /// 初回起動チェック

        /// </summary>

        /// <returns></returns>

        private bool ExecuteCheck(ref DateTime lastsessionDate)

        {

            IOSystemExecute seDB = new IOSystemExecute();

            try

            {

                // キーを取得する

                int PCode = CommonDefine.ExePrimaryCode.First(x => x.Value.Equals("初回起動日付")).Key;

                // 日付読込

                string strSQL = seDB.CreatePrimarykeyString(PCode);

                SystemExecute recordRec = new SystemExecute();

                if (!seDB.SelectAction(strSQL, ref recordRec))

                {

                    // キーセット

                    recordRec.PrimaryCode = PCode;

                    // 起動日付

                    recordRec.TargetDate = DateTime.Now;

                    // データがないもしくはエラー時はデータ作成

                    if (!seDB.InsertAction(recordRec)) return false;

                    // 日付を1日前にする

                    recordRec.TargetDate = DateTime.Now.AddDays(-1);

                }

                // 前回起動日を取得する

                lastsessionDate = recordRec.TargetDate;

                // 日付比較

                if (DateTime.Today == recordRec.TargetDate.Date) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

            finally

            {

                seDB.close(); seDB = null;

            }

        }

        #endregion

        #region 日付変更

        /// <summary>

        /// 日付変更

        /// </summary>

        /// <returns></returns>

        private bool UpDateTargetDate(DateTime TargetDate)

        {

            IOSystemExecute seDB = new IOSystemExecute();

            try

            {

                // キーを取得する

                int PCode = CommonDefine.ExePrimaryCode.First(x => x.Value.Equals("初回起動日付")).Key;

                // 日付更新

                if (!seDB.UpdateFeild(PCode, (int)IOSystemExecute.TableColumn.TargetDate, TargetDate)) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

            finally

            {

                seDB.close(); seDB = null;

            }

        }

        #endregion

        #region 期限マスタ読込

        /// <summary>

        /// 期限マスタ読込

        /// </summary>

        /// <returns></returns>

        private bool GetTermList()

        {

            IOMTerm tmDB = new IOMTerm();

            try

            {

                // 期限マスタ読込

                string strSQL = " Order By ConstructionStatusFlg Asc, DisplayOrder Asc";

                List<TermMaster> tmList = new List<TermMaster>();

                if (!tmDB.SelectAction(strSQL, ref tmList)) return false;

                // ラストのためにループ外で定義

                TermMasterList CheckList = null;

                int iTmpStatus = -1;

                // データセット

                foreach (TermMaster tmRec in tmList)

                {

                    // キーが違えばArrayテーブルへ追加する

                    if (iTmpStatus != tmRec.ConstructionStatusFlg)

                    {

                        // チェックテーブルへ新たな状態テーブルを追加

                        CheckList = new TermMasterList();

                        SystemOnceExecuteTermMstList.Add(CheckList);

                        // ブレイクキーの更新

                        iTmpStatus = tmRec.ConstructionStatusFlg;

                    }

                    // 取得データをセットする

                    CheckList.TermMstTBL.Add(tmRec);

                }

                // バッファテーブルが空ではない場合

                if (CheckList.TermMstTBL.Count != 0)

                {

                    // マスターテーブルリストより最後のステータスを取得する

                    int SetTableStatus = SystemOnceExecuteTermMstList[SystemOnceExecuteTermMstList.Count - 1].TermMstTBL[0].ConstructionStatusFlg;

                    // バッファテーブルのステータスを取得する

                    int NowStatus = CheckList.TermMstTBL[0].ConstructionStatusFlg;

                    // バッファテーブルがすでにセットされていなければセットする

                    if (SetTableStatus != NowStatus) SystemOnceExecuteTermMstList.Add(CheckList);

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

            finally

            {

                tmDB.close(); tmDB = null;

            }

        }

        #endregion

        #region 資材返却ステータス取得処理

        /// <summary>

        /// 資材返却ステータス取得処理

        /// </summary>

        /// <returns></returns>

        public void MaterualStatusCheck(MaterialRecordInfo checkRec, DateTime CriteriaDate, ref TermMaster TermRec)

        {

            try

            {

                // 対象日付を設定

                DateTime Target = checkRec.RepayPlanDate;

                TermMaster TermMasterData = new TermMaster();

                // 当日のチェック 今日を基準に対象日と比較する

                if (Target.Date == CriteriaDate.Date)

                {

                    TermMasterData.CheckSchdule = (int)CommonDefine.TermDateCheckTiming.CheckSchdule1;

                    TermMasterData.TermDays     = CommonDefine.MaterualStatusCheckList[0].Value;

                    TermMasterData.SendTitle    = CommonDefine.MaterualLimitItem[0, 0];

                    TermMasterData.SendMessage  = CommonDefine.MaterualLimitItem[0, 1];

                    TermMasterData.BackColor    = CommonDefine.MaterualLimitItem[0, 2];

                    TermMasterData.ForeColor    = CommonDefine.MaterualLimitItem[0, 3];

                }

                // 後日以降継続のチェック 今日を基準に経過日（1日）が過ぎているか比較する

                if (Target.AddDays(1).Date <= CriteriaDate.Date)

                {

                    TermMasterData.CheckSchdule = (int)CommonDefine.TermDateCheckTiming.CheckSchdule3;

                    TermMasterData.TermDays     = CommonDefine.MaterualStatusCheckList[1].Value;

                    TermMasterData.SendTitle    = CommonDefine.MaterualLimitItem[1, 0];

                    TermMasterData.SendMessage  = CommonDefine.MaterualLimitItem[1, 1];

                    TermMasterData.BackColor    = CommonDefine.MaterualLimitItem[1, 2];

                    TermMasterData.ForeColor    = CommonDefine.MaterualLimitItem[1, 3];

                }

                TermRec = TermMasterData;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

            }

        }

        #endregion

        #region 秘書からのメッセージ作成

        /// <summary>

        /// 秘書からのメッセージ作成

        /// </summary>

        private bool MakeSecretaryMassageData(IOMessageBoardData mbdDB,

                                        IOMessageBoardTerget mbtDB,

                                        IOConstructionBaseInfoDetail cbiDB,

                                        MaterialRecordInfo wrkRec, TermMaster CheckRec, DateTime CriteriaDate)

        {

            try

            {

                // 工事名称・担当者取得

                string strSQL = "SELECT A.DETAILSTRING, C.PERSONCODE CCODE, C.PERSONNAME CNAME";

                strSQL += " FROM ConstructionBaseInfo P";

                strSQL += string.Format(" LEFT JOIN PERSONINCHARGEMASTER C ON C.PERSONCODE = {0}", wrkRec.PersonCode);

                strSQL += " , CONSTRUCTIONBASEINFODETAIL A";

                strSQL += string.Format(" WHERE P.CONSTRUCTIONCODE = {0}", wrkRec.ConstructionCode);

                strSQL += string.Format(" AND A.CONSTRUCTIONCODE = P.CONSTRUCTIONCODE AND A.DETAILNO = {0}", (int)ConstructionBaseInfoDetail.DetailDataNo.ConstructionName);

                ArrayList arList = new ArrayList();

                if (!cbiDB.ExecuteReader(strSQL, ref arList)) return false;

                string DetailString = string.Empty;

                //int SalesPersonCode = 0;

                string SalesPersonName = string.Empty;

                int ConstructionPersonCode = 0;

                string ConstructionPersonName = string.Empty;

                foreach (object[] onjwrk in arList)

                {

                    DetailString = CommonMotions.cnvString(onjwrk[0]);

                    ConstructionPersonCode = CommonMotions.cnvInt(onjwrk[1]);

                    ConstructionPersonName = CommonMotions.cnvString(onjwrk[2]);

                    break;

                }

                // 新規メッセージ作成

                MessageBoardData WriteData = new MessageBoardData();

                List<MessageBoardTerget> WriteDetail = new List<MessageBoardTerget>();

                // 掲示板メッセージ

                WriteData.FromCode = CommonDefine.s_MsgBoardSystemCode;	                                    // 書込み者コード

                WriteData.FromName = string.Format(CommonDefine.s_MsgBoardSystemNameFormat, "秘書");        // 書込み者名

                WriteData.MessageTitle = CheckRec.SendTitle;                                                // 伝言タイトル

                // リンク情報

                WriteData.LinkType = (int)CommonDefine.LinkType.ConstructionInfo;

                WriteData.LinkMessage = string.Format("工事番号：{0} 工事名称：{1}"

                                                                            , CommonMotions.cnvStringCodeFromInt(wrkRec.ConstructionCode, "-", 8)

                                                                            , DetailString);

                WriteData.LinkCode = string.Format("{0}", CommonMotions.cnvStringCodeFromInt(wrkRec.ConstructionCode, "-", 8));

                // 伝言内容

                WriteData.MessageContent = CheckRec.SendMessage;

                //WriteData.WritingDate = DateTime.Now;	                                                    // 書込み日付

                WriteData.WritingDate = CriteriaDate.Date + DateTime.Now.TimeOfDay;	                        // 書込み日付

                WriteData.PersonCode = CommonDefine.s_MsgBoardSystemCode;	                                // 書込み担当者コード

                WriteData.ShareFlag = 1;	                                                                // 管理者対象フラグ

                WriteData.BackColor = CheckRec.BackColor;                                                   // 背景色セット

                WriteData.MessageColor = CheckRec.ForeColor;                                                // 背景色セット

                // 掲示板対象者テーブル

                MessageBoardTerget DetailTbl = new MessageBoardTerget();

                DetailTbl.ToCode = ConstructionPersonCode;                                                  // 対象者コード

                DetailTbl.ToName = ConstructionPersonName;	                                                // 対象者

                WriteDetail.Add(DetailTbl);

                // メッセージフラグを自動に設定する

                WriteData.MessageFlag = (int)CommonDefine.MessageFlg.Secretary;

                // 掲示板へメッセージを載せる

                if (!ClsMessageBoradAccess.CreateMessage(mbdDB, mbtDB, WriteData, WriteDetail)) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

                return false;

            }

        }

        #endregion

        #region 資材返却期限チェック処理

        /// <summary>

        /// チェック処理

        /// </summary>

        /// <returns></returns>

        public bool MaterialLimitCheck(DateTime StartDate)

        {

            IOConstructionBaseInfo cbiDB = new IOConstructionBaseInfo();

            IOConstructionBaseInfoDetail cbiDDB = new IOConstructionBaseInfoDetail();

            IOMessageBoardData mbdDB = new IOMessageBoardData();

            IOMessageBoardTerget mbtDB = new IOMessageBoardTerget();

            string strSQL = "SELECT";

            strSQL += " t1.MaterialItemCode";

            strSQL += ", t1.ProcessDate";

            strSQL += ", t1.SeqNo";

            strSQL += ", t1.RecKind";

            strSQL += ", t1.ConstructionCode";

            strSQL += ", t1.PersonCode";

            strSQL += ", t1.MaterialCount";

            strSQL += ", MAX(t1.REPAYPLANDATE) AS RepayPlanDate";

            strSQL += ", t1.CommentText";

            strSQL += ", t1.EntryDate";

            strSQL += ", t1.UpdateDate";

            strSQL += " FROM";

            strSQL += " MATERIALRECORDINFO AS t1";

            strSQL += " INNER JOIN CONSTRUCTIONMATERIALINFO AS t2";

            strSQL += " ON t1.CONSTRUCTIONCODE = t2.CONSTRUCTIONCODE";

            strSQL += " AND t1.MATERIALITEMCODE = t2.MATERIALITEMCODE";

            strSQL += " AND t2.COMPLETEFLG = 0";

            strSQL += " WHERE";

            strSQL += " t1.CONSTRUCTIONCODE > 0";

            strSQL += " AND t1.CONSTRUCTIONCODE IS NOT NULL";

            strSQL += " AND t1.RECKIND = 0";

            strSQL += " AND t1.REPAYPLANDATE <= DATE_FORMAT(NOW(), '%Y/%m/%d')";

            strSQL += " GROUP BY";

            strSQL += " t1.CONSTRUCTIONCODE";

            strSQL += ", t1.PERSONCODE";

            strSQL += " ORDER BY";

            strSQL += " t1.CONSTRUCTIONCODE";

            strSQL += " , t1.REPAYPLANDATE";

            try

            {

                cbiDB.connect(); cbiDB.beginTran();

                cbiDDB.connect(); cbiDDB.beginTran();

                mbdDB.connect(); mbdDB.beginTran();

                mbtDB.connect(); mbtDB.beginTran();

                bool procflg = true;

                // 資材履歴情報の返却未完了の貸出データを取得する

                IOMaterialRecordInfo mrDB = new IOMaterialRecordInfo();

                ArrayList mrData = new ArrayList();

                List<MaterialRecordInfo> data = new List<MaterialRecordInfo>();

                if (mrDB.ExecuteReader(strSQL, ref mrData))

                {

                    foreach (object[] objwrk in mrData)

                    {

                        MaterialRecordInfo wrkRec = new MaterialRecordInfo();

                        mrDB.Reader2Struct(objwrk, ref wrkRec);

                        // チェック

                        TermMaster term = new TermMaster();

                        MaterualStatusCheck(wrkRec, StartDate, ref term);

                        // メッセージ作成 掲示板にメッセージを載せる処理

                        if (!MakeSecretaryMassageData(mbdDB, mbtDB, cbiDDB, wrkRec, term, StartDate))

                        {

                            procflg = false;

                            break;

                        }

                    }

                    if (procflg)

                    {

                        cbiDB.commit();

                        cbiDDB.commit();

                        mbdDB.commit();

                        mbtDB.commit();

                    }

                    else

                    {

                        cbiDB.rollback();

                        cbiDDB.rollback();

                        mbdDB.rollback();

                        mbtDB.rollback();

                    }

                    return procflg;

                }

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

                return false;

            }

            finally

            {

                cbiDB.close(); cbiDB = null;

                cbiDDB.close(); cbiDDB = null;

                mbdDB.close(); mbdDB = null;

                mbtDB.close(); mbtDB = null;

            }

            return true;

        }

        #endregion

        #region 工事情報チェック処理

        /// <summary>

        /// 日付の期限チェックを行う

        /// </summary>

        private bool SubmittedDateCheck(DateTime StartDate)

        {

            IOConstructionBaseInfo cbiDB = new IOConstructionBaseInfo();

            IOConstructionBaseInfoDetail cbiDDB = new IOConstructionBaseInfoDetail();

            IOMessageBoardData mbdDB = new IOMessageBoardData();

            IOMessageBoardTerget mbtDB = new IOMessageBoardTerget();

            try

            {

                // 工事基本情報を期限テーブルに設定している状態分取得する

                string strSQL = " WHERE CONSTRUCTIONSTATUSFLG IN (SELECT DISTINCT A1.CONSTRUCTIONSTATUSFLG FROM TERMMASTER A1)";

                strSQL = " ORDER BY CONSTRUCTIONSTATUSFLG ASC, CONSTRUCTIONCODE ASC";

                List<ConstructionBaseInfo> cbiList = new List<ConstructionBaseInfo>();

                if (!cbiDB.SelectAction(strSQL, ref cbiList)) return true;

                // 経過日数を取得する

                TimeSpan ts = DateTime.Now - StartDate;

                int diffDays = ts.Days;

                // チェック範囲が１０日を超えたら当日だけチェックする

                if (diffDays > 10)

                {

                    diffDays = 1;

                    StartDate = DateTime.Now.AddDays(-1);

                }

                cbiDB.connect(); cbiDB.beginTran();

                cbiDDB.connect(); cbiDDB.beginTran();

                mbdDB.connect(); mbdDB.beginTran();

                mbtDB.connect(); mbtDB.beginTran();

                bool procflg = true;

                // 経過日数分処理を行う

                for (int ix = 0; ix < diffDays; ix++)

                {

                    DateTime CriteriaDate = StartDate.AddDays((ix + 1));

                    foreach (ConstructionBaseInfo wrkRec in cbiList)

                    {

                        List<TermMaster> term = new List<TermMaster>();

                        // 増減工事の子は処理しない

                        if (wrkRec.TyingFlg == (int)CommonDefine.BaseInfoTyingFlg.Tying) continue;

                        // 結合工事の親は処理しない

                        if (wrkRec.JoinFlg == (int)CommonDefine.BaseInfoJoinFlg.JoinParent) continue;

                        // 結合工事の子は処理しない

                        if (wrkRec.JoinFlg == (int)CommonDefine.BaseInfoJoinFlg.JoinChildren) continue;

                        // チェックOKならば次のデータ

                        if (ConstructionStatusCheck(wrkRec, CriteriaDate, ref term)) continue;

                        // 掲示板にメッセージを載せるためにループ処理

                        foreach (TermMaster CurTerm in term)

                        {

                            // メッセージ作成

                            if (!MakeMassageData(mbdDB, mbtDB, cbiDDB, wrkRec, CurTerm, CriteriaDate))

                            {   // エラー時に抜ける

                                procflg = false;

                                break;

                            }

                        }

                        if (!procflg) break;

                    }

                    if (!procflg) break;

                }

                if (!procflg)

                {

                    cbiDB.rollback();

                    cbiDDB.rollback();

                    mbdDB.rollback();

                    mbtDB.rollback();

                }

                return procflg;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

                return false;

            }

            finally

            {

                cbiDB.commit();

                cbiDDB.commit();

                mbdDB.commit();

                mbtDB.commit();

                cbiDB.close(); cbiDB = null;

                cbiDDB.close(); cbiDDB = null;

                mbdDB.close(); mbdDB = null;

                mbtDB.close(); mbtDB = null;

            }

        }

        #endregion

        #region チェック処理

        /// <summary>

        /// チェック処理

        /// </summary>

        /// <returns></returns>

        public bool ConstructionStatusCheck(ConstructionBaseInfo checkRec, DateTime CriteriaDate, ref List<TermMaster> TermRec)

        {

            try

            {

                // 初期化に失敗していたら処理しない

                if (!m_bExecuteFlg) return true;

                // 取得データの進捗状態がチェック判定テーブルにあるかの存在チェック

                bool exestFlg = false;

                int itblCnt = 0;

                for (int i = 0; i < SystemOnceExecuteTermMstList.Count; i++)

                {

                    // 判定対象データの状態がチェック判定テーブルにあれば処理をおこなう

                    if (SystemOnceExecuteTermMstList[i].TermMstTBL[0].ConstructionStatusFlg == checkRec.ConstructionStatusFlg)

                    {

                        exestFlg = true;

                        itblCnt = i;

                        break;

                    }

                }

                // 取得データがチェック判定以外は処理しない

                if (!exestFlg) return true;

                // 戻り値

                bool bCheckNoError = true;

                List<TermMaster> Termtbl = SystemOnceExecuteTermMstList[itblCnt].TermMstTBL;

                // エラーチェック

                foreach (TermMaster wrkCheck in Termtbl)

                {

                    // 対象日付をクリア

                    DateTime Target = DateTime.MinValue;

                    switch (wrkCheck.FieldNo)

                    {

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.RequestedDate:               // 依頼受け日

                            Target = checkRec.RequestedDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.EstimatesSubmitDeadline:     // 見積提出期限

                            Target = checkRec.EstimatesSubmitDeadline;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.EstimatesSubmittedDate:      // 見積提出日

                            Target = checkRec.EstimatesSubmittedDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.OrderDate:                   // 受注日

                            Target = checkRec.OrderDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.OrderStartingDate:           // 開始予定日

                            Target = checkRec.OrderStartingDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.OrderCompletionDate:         // 完了予定日

                            Target = checkRec.OrderCompletionDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.ConstrPreparationDate:       // 施工開始準備日

                            Target = checkRec.PreparationStartDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.ConstructionStartingDate:    // 施工開始日

                            Target = checkRec.ConstructionStartingDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.ConstructionCompletionDate:  // 施工完了日

                            Target = checkRec.ConstructionCompletionDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.TransferConstructionDate:    // 工事移管日

                            Target = checkRec.TransferConstructionDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.EstimatesExpirationDate:     // 見積有効期限

                            Target = checkRec.EstimatesExpirationDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.ConstructionPeriodStart:     // 契約工期開始

                            Target = checkRec.ConstructionPeriodStart;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.ConstructionPeriodEnd:       // 契約工期完了

                            Target = checkRec.ConstructionPeriodEnd;

                            // 延長工期があれば延長工期を入れる

                            if (checkRec.ConstructionPeriodEnd2 != DateTime.MinValue) Target = checkRec.ConstructionPeriodEnd2;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.BillingStartDate:            // 請求準備開始日

                            Target = checkRec.BillingStartDate;

                            break;

                        case (int)CommonDefine.ConstructionBaseInfo_DateNo.BillingDate:                 // 請求日

                            Target = checkRec.BillingDate;

                            // 2016/10/06 台帳入力完了日があればチェックをしない 

                            if (checkRec.LedgerComplateDate != DateTime.MinValue) Target = DateTime.MinValue.Date;

                            break;

                    }

                    // 未定の日付はチェックしない

                    if (Target.Date == DateTime.MinValue.Date) continue;

                    // エラーフラグクリア

                    bool ErrFlg = false;

                    switch (wrkCheck.CheckSchdule)

                    {

                        case (int)CommonDefine.TermDateCheckTiming.CheckSchdule0:   // 前日以前のチェック

                            // 今日を基準に経過日を加算して対象日と比較する

                            //if (Target.Date == DateTime.Now.AddDays(wrkCheck.TermDays).Date)

                            if (Target.Date == CriteriaDate.AddDays(wrkCheck.TermDays).Date)

                            {

                                ErrFlg = true;

                            }

                            break;

                        case (int)CommonDefine.TermDateCheckTiming.CheckSchdule1:   // 当日のチェック

                            // 今日を基準に対象日と比較する

                            //if (Target.Date == DateTime.Now.Date)

                            if (Target.Date == CriteriaDate.Date)

                            {

                                ErrFlg = true;

                            }

                            break;

                        case (int)CommonDefine.TermDateCheckTiming.CheckSchdule2:   // 後日以降のチェック

                            // 今日を基準に対象日と比較する

                            //if (Target.AddDays(wrkCheck.TermDays).Date == DateTime.Now.Date)

                            if (Target.AddDays(wrkCheck.TermDays).Date == CriteriaDate.Date)

                            {

                                ErrFlg = true;

                            }

                            break;

                        case (int)CommonDefine.TermDateCheckTiming.CheckSchdule3:   // 後日以降継続のチェック

                            // 今日を基準に経過日が過ぎているとエラー

                            //if (Target.AddDays(wrkCheck.TermDays).Date <= DateTime.Now.Date)

                            if (Target.AddDays(wrkCheck.TermDays).Date <= CriteriaDate.Date)

                            {

                                ErrFlg = true;

                            }

                            break;

                    }

                    // チェック項目に該当すればメッセージ・色をセットする

                    if (ErrFlg)

                    {

                        TermRec.Add(wrkCheck);

                        bCheckNoError = false;

                    }

                }

                return bCheckNoError;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

                return false;

            }

        }

        #endregion

        #region 掲示板メッセージ作成

        /// <summary>

        /// メッセージ作成

        /// </summary>

        private bool MakeMassageData(IOMessageBoardData mbdDB,

                                        IOMessageBoardTerget mbtDB,

                                        IOConstructionBaseInfoDetail cbiDB,

                                        ConstructionBaseInfo wrkRec, TermMaster CheckRec, DateTime CriteriaDate)

        {

            try

            {

                // 工事名称・営業担当者・工事担当者取得

                string strSQL = "SELECT A.DETAILSTRING, B.PERSONCODE SCODE, B.PERSONNAME SNAME, C.PERSONCODE CCODE, C.PERSONNAME CNAME";

                strSQL += " FROM CONSTRUCTIONBASEINFO P";

                strSQL += " LEFT JOIN PERSONINCHARGEMASTER B ON B.PERSONCODE = P.SALESPERSONCODE";

                strSQL += " LEFT JOIN PERSONINCHARGEMASTER C ON C.PERSONCODE = P.CONSTRUCTIONPERSONCODE";

                strSQL += " , CONSTRUCTIONBASEINFODETAIL A";

                strSQL += string.Format(" WHERE P.CONSTRUCTIONCODE = {0}",wrkRec.ConstructionCode);

                strSQL += string.Format(" AND A.CONSTRUCTIONCODE = P.CONSTRUCTIONCODE AND A.DETAILNO = {0}", (int)ConstructionBaseInfoDetail.DetailDataNo.ConstructionName);

                ArrayList arList = new ArrayList();

                if (!cbiDB.ExecuteReader(strSQL, ref arList)) return false;

                string DetailString = string.Empty;

                int SalesPersonCode = 0;

                string SalesPersonName = string.Empty;

                int ConstructionPersonCode = 0;

                string ConstructionPersonName = string.Empty;

                foreach (object[] onjwrk in arList)

                {

                    DetailString = CommonMotions.cnvString(onjwrk[0]);

                    SalesPersonCode = CommonMotions.cnvInt(onjwrk[1]);

                    SalesPersonName = CommonMotions.cnvString(onjwrk[2]);

                    ConstructionPersonCode = CommonMotions.cnvInt(onjwrk[3]);

                    ConstructionPersonName = CommonMotions.cnvString(onjwrk[4]);

                    break;

                }

                // 新規メッセージ作成

                MessageBoardData WriteData = new MessageBoardData();

                List<MessageBoardTerget> WriteDetail = new List<MessageBoardTerget>();

                // 掲示板メッセージ

                WriteData.FromCode = CommonDefine.s_MsgBoardSystemCode;	                                    // 書込み者コード

                WriteData.FromName = string.Format(CommonDefine.s_MsgBoardSystemNameFormat, "秘書");          // 書込み者名

                WriteData.MessageTitle = CheckRec.SendTitle;                                              // 伝言タイトル

                // リンク情報

                WriteData.LinkType = (int)CommonDefine.LinkType.ConstructionInfo;

                WriteData.LinkMessage = string.Format("工事番号：{0} 工事名称：{1}"

                                                                            , CommonMotions.cnvStringCodeFromInt(wrkRec.ConstructionCode, "-", 8)

                                                                            , DetailString);

                WriteData.LinkCode = string.Format("{0}", CommonMotions.cnvStringCodeFromInt(wrkRec.ConstructionCode, "-", 8));

                // 伝言内容

                WriteData.MessageContent = CheckRec.SendMessage;

                //WriteData.WritingDate = DateTime.Now;	                                                    // 書込み日付

                WriteData.WritingDate = CriteriaDate.Date + DateTime.Now.TimeOfDay;	                        // 書込み日付

                WriteData.PersonCode = CommonDefine.s_MsgBoardSystemCode;	                                // 書込み担当者コード

                WriteData.ShareFlag = 1;	                                                                // 管理者対象フラグ

                WriteData.BackColor = CheckRec.BackColor;                                                   // 背景色セット

                WriteData.MessageColor = CheckRec.ForeColor;                                                // 背景色セット

                // 掲示板対象者テーブル

                MessageBoardTerget DetailTbl = new MessageBoardTerget();

                DetailTbl.ToCode = SalesPersonCode;                                                     // 対象者コード

                DetailTbl.ToName = SalesPersonName;	                                                    // 対象者

                if (ConstructionPersonCode != 0)

                {

                    DetailTbl.ToCode = ConstructionPersonCode;                                          // 対象者コード

                    DetailTbl.ToName = ConstructionPersonName;	                                        // 対象者

                }

                WriteDetail.Add(DetailTbl);

                // メッセージフラグを自動に設定する

                WriteData.MessageFlag = (int)CommonDefine.MessageFlg.Secretary;

                // 掲示板へメッセージを載せる

                if (!ClsMessageBoradAccess.CreateMessage(mbdDB, mbtDB, WriteData, WriteDetail)) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}", ex.Message);

                return false;

            }

        }

        #endregion

        #region 見積有効期限が経過したデータを非受注へ変更する

        /// <summary>

        /// 見積有効期限が経過したデータを非受注へ変更する

        /// </summary>

        private bool ChangeNonOrdersData()

        {

            IOConstructionBaseInfo BaseDB = new IOConstructionBaseInfo();

            IOConstructionBaseInfoDetail DetailDB = new IOConstructionBaseInfoDetail();

            try

            {

                int iCode1 = CommonDefine.ProjectsStatus.First(x => x.Value.Equals("非 受 注")).Key;

                int iCode2 = CommonDefine.ProjectsStatus.First(x => x.Value.Equals("依頼受け中")).Key;

                int iCode3 = CommonDefine.ProjectsStatus.First(x => x.Value.Equals("見積提出")).Key;

                // 対象データが存在するかを確認する

                string strSQL = "SELECT A.CONSTRUCTIONCODE, B.DETAILSTRING FROM CONSTRUCTIONBASEINFO A";

                strSQL += " LEFT JOIN CONSTRUCTIONBASEINFODETAIL B ON B.CONSTRUCTIONCODE = A.CONSTRUCTIONCODE";

                strSQL += string.Format(" AND B.DETAILNO = {0}", (int)ConstructionBaseInfoDetail.DetailDataNo.OrdersDecisionComment);

                string strWHERE = " WHERE DATE(A.ESTIMATESSUBMITTEDDATE) != STR_TO_DATE('0001/01/01', '%Y/%m/%d')";

                strWHERE += string.Format(" AND DATE(DATE_ADD(ESTIMATESSUBMITTEDDATE, INTERVAL '{0}' DAY))", s_NonOrderDay);

                strWHERE += string.Format(" < STR_TO_DATE('{0}','%Y/%m/%d')", DateTime.Now.ToShortDateString());

                strWHERE += string.Format(" AND A.CONSTRUCTIONSTATUSFLG IN({0}, {1})", iCode2, iCode3);

                strWHERE += string.Format(" AND A.ESTIMATETYPE IN ({0}, {1})", (int)CommonDefine.BaseInfoEstimateType.Normal, (int)CommonDefine.BaseInfoEstimateType.GetBudget);

                strSQL += strWHERE;

                ArrayList arList = new ArrayList();

                if (!BaseDB.ExecuteReader(strSQL, ref arList))

                {

                    logger.ErrorFormat("工事基本情報読込エラー　非受注案件移行処理失敗：{0}：{1}", CommonMotions.GetMethodName(), strSQL);

                    return false;

                }

                // ----- 対象データが存在しなければ抜ける

                if (arList.Count == 0) return true;

                // ----- 対象データが存在すれば更新する

                BaseDB.connect(); BaseDB.beginTran();

                DetailDB.connect(); DetailDB.beginTran();

                // 工事基本情報データ

                strSQL = string.Format("UPDATE CONSTRUCTIONBASEINFO A SET A.CONSTRUCTIONSTATUSFLG = {0},", iCode1);

                strSQL += string.Format(" A.NONORDERDATE = STR_TO_DATE('{0}','%Y/%m/%d')", DateTime.Today.ToShortDateString());

                strSQL += strWHERE;