Option Explicit
    Const Pmax As Long = 100    '従業員人の最大数
    Const Rmax As Long = 600    '1ピボットシート内の1人のひと月の最大行数
 
    Dim HON1Rows(Pmax, Rmax) As Long  '本年1部の行情報
    '                                   左側の添字＝各個人に割当られた番号(0-100)
    '                                   右側の添字＝0番目は以降の要素数を示す。（例 この値が3の時、要素数3なので、3番目の添字まで有効）
    '                                   右側の添字＝1番目以降は、行番号を示す。
    Dim HON2Rows(Pmax, Rmax) As Long  '本年2部の行情報（添字は本年1部と同様）
    Dim HON3Rows(Pmax, Rmax) As Long  '本年3部の行情報（添字は本年1部と同様）
    Dim HON1dicT As Object            '本年1部の辞書　キー：支店名＋課名＋個人名 値：行情報テーブルの添字(0-100)
    Dim HON2dicT As Object            '本年2部の辞書 （キーと値は本年1部と同様）
    Dim HON3dicT As Object            '本年3部の辞書 （キーと値は本年1部と同様）
    Const HON1sheet As String = "1部本年P"
    Const HON2sheet As String = "2部本年P"
    Const HON3sheet As String = "3部本年P"
    Const JISSEKI As String = "実績"           '実績
    Const ZENNEN  As String = "前年"           '前年
    Dim Uri_book As String              '売上明細データブック名
    Dim trg_yyyy As Long                '指定年
    Dim trg_mm As Long                  '指定月
    Dim Jis_folder As String            '実績フォルダ
    Dim Kei_folder As String            '計画フォルダ
    Dim trg_key As String               '個人名キー
    Dim trg_col As Long                 '算出カラム番号
    Dim trg_mode As String              '実績/前年
    Dim warnP As String                 '警告従業員
Public Sub 売上月単位集計()
    Dim ws As Worksheet
    Dim yyyy, mm, ext As Variant
    Dim t1, t2 As Variant
    Dim Uri_path As String
    Set HON1dicT = CreateObject("Scripting.Dictionary")
    Set HON2dicT = CreateObject("Scripting.Dictionary")
    Set HON3dicT = CreateObject("Scripting.Dictionary")
    Set ws = Worksheets("管理")
    yyyy = ws.Cells(2, "A").Value               '集計年
    If yyyy = "" Or IsNumeric(yyyy) = False Then
        MsgBox ("集計年月が不正")
        Exit Sub
    End If
    trg_yyyy = yyyy
    If trg_yyyy < 2010 Or trg_yyyy > 2099 Then
        MsgBox ("集計年月(2010-2099)が範囲外")
        Exit Sub
    End If
    mm = ws.Cells(2, "B").Value                 '集計月
    If mm = "" Or IsNumeric(mm) = False Then
        MsgBox ("集計月が不正")
        Exit Sub
    End If
    trg_mm = mm
    If trg_mm < 1 Or trg_mm > 12 Then
        MsgBox ("集計月(1-12)が範囲外")
        Exit Sub
    End If
    trg_mode = ws.Cells(2, "C").Value           '集計項目
    If trg_mode <> JISSEKI And trg_mode <> ZENNEN Then
        MsgBox ("集計項目が不正")
        Exit Sub
    End If
    Jis_folder = ws.Cells(2, "D").Value            '実績フォルダ名
    Uri_book = ws.Cells(2, "E").Value              '実績売上明細ファイル
    '拡張子のチェック
    ext = Right(LCase(Uri_book), 5)
    If ext <> ".xlsx" And ext <> ".xlsm" Then
        MsgBox ("実績ファイル名が不正")
        Exit Sub
    End If
    Kei_folder = ws.Cells(2, "F").Value            '計画フォルダ名
 
    If Dir(Jis_folder, vbDirectory) = "" Then
        MsgBox ("実績フォルダが存在しません<" & Jis_folder & ">")
        Exit Sub
    End If
    If Dir(Kei_folder, vbDirectory) = "" Then
        MsgBox ("計画フォルダが存在しません<" & Kei_folder & ">")
        Exit Sub
    End If
    '売上明細ブック名設定
    Uri_path = Jis_folder & "\" & Uri_book
    'MsgBox ("ファイル名<" & Uri_book & ">") '追加①
    'MsgBox ("フルパス名<" & Uri_path & ">") '追加②
    'MsgBox (GetAttr(Uri_path)) '追加③
    If Dir(Uri_path) = "" Then
        MsgBox (Uri_path & "が存在しません")
        Exit Sub
    End If
 
    If MsgBox(trg_yyyy & "年" & trg_mm & "月の" & trg_mode & "を" & Uri_book & "から集計します", vbOKCancel) <> vbOK Then Exit Sub
    t1 = Timer
    warnP = ""
    Application.ScreenUpdating = False
    '売上明細ブック名オープン
    Workbooks.Open Uri_path
    Workbooks(Uri_book).Activate
    'ピボットデータ読み込み
    Call readPivot(HON1sheet, HON1dicT, HON1Rows)
    Call readPivot(HON2sheet, HON2dicT, HON2Rows)
    Call readPivot(HON3sheet, HON3dicT, HON3Rows)
    Call OutPivot 'ピボット情報出力・・・・・追加①
    '計画フォルダ内の全ブックを更新する
    Call UpdateAllBooks(Kei_folder)
    Workbooks(Uri_book).Close
    Application.ScreenUpdating = True
    t2 = Timer
    MsgBox ("処理完了 所要時間(秒)=" & t2 - t1)
    If warnP <> "" Then
        MsgBox ("下記従業員は、1部,2部,3部の何れのピボットにも集計月のデータなし。" & vbLf & warnP)
    End If
End Sub
 
'計画フォルダ内の全てのブックを更新する
Private Sub UpdateAllBooks(ByVal Kei_folder As String)
    Dim bookname As String
    bookname = Dir(Kei_folder & "\*.xlsx", vbNormal)
    If bookname = "" Then
        MsgBox (Kei_folder & "内に支店別＆課別（個人データ）ブックが存在しません。")
        End
    End If
    '全てのブックを更新する
    Do While bookname <> ""
        Call Update1Book(Kei_folder, bookname)
        bookname = Dir()
    Loop
End Sub
 
'１つのブックを更新する
Private Sub Update1Book(ByVal Kei_folder As String, ByVal bookname As String)
    Dim ws As Worksheet
    Dim i As Long
    Workbooks.Open Kei_folder & "\" & bookname
    '左側のシートから順に処理する
    For i = 1 To Worksheets.count
        Set ws = Worksheets(i)
        '合計シート検出時、終了
        If ws.name = "合計" Then Exit For
        If ws.name = "拠点計" Then Exit For '追加②
        '１つのシートを更新する
        Call Update1Sheet(bookname, ws)
    Next
    'ブックを保存し、閉じる
    Workbooks(bookname).Save
    Workbooks(bookname).Close
End Sub
'１つのシートを更新する
Private Sub Update1Sheet(ByVal bookname As String, ByVal ws As Worksheet)
    '支店名＋課名＋担当者名
    trg_key = ws.Cells(2, "C").Value & "|" & ws.Cells(3, "C").Value & "|" & ws.Cells(4, "C").Value
    '1部,2部,3部のピボットシート内に担当者の集計月の行が１件もない場合は、警告メッセージを出力し、その担当者をスキップする
    If HON1dicT.exists(trg_key) = False And HON2dicT.exists(trg_key) = False And HON3dicT.exists(trg_key) = False Then
        warnP = warnP & bookname & "(" & ws.name & ")" & trg_key & vbLf
    End If
    '集計月に対応するカラム位置を取得
    trg_col = GetColNumber(trg_mm)
    '個人シートに値を設定する
    Call set_value(bookname, ws, trg_mode)
End Sub
'個人シートに値の設定を行う
Private Sub set_value(ByVal bookname As String, ByVal ws As Worksheet, ByVal mode As String)
    Dim col1 As Long    '数量のカラム位置
    Dim col2 As Long    '粗利のカラム位置
    'カラム位置の設定
    col1 = trg_col + 3
    col2 = trg_col + 8
    '実績（当年）の場合は1カラム右へ設定
    If mode = JISSEKI Then
        col1 = col1 + 1
        col2 = col2 + 1
    End If
    '3部集計
    '                                 PVシート名,取得列,条件列,条件値,PV辞書,PV行情報
    ws.Cells(9, col1).Value = GetValue(HON3sheet, "I", "H", "1", HON3dicT, HON3Rows)      'A（数量）
    ws.Cells(9, col2).Value = GetValue(HON3sheet, "K", "H", "1", HON3dicT, HON3Rows)      'A（粗利）
    ws.Cells(10, col1).Value = GetValue(HON3sheet, "I", "H", "2", HON3dicT, HON3Rows)      'B（数量）
    ws.Cells(10, col2).Value = GetValue(HON3sheet, "K", "H", "2", HON3dicT, HON3Rows)      'B（粗利）
    ws.Cells(11, col1).Value = GetValue(HON3sheet, "I", "H", "3", HON3dicT, HON3Rows)      'C（数量）
    ws.Cells(11, col2).Value = GetValue(HON3sheet, "K", "H", "3", HON3dicT, HON3Rows)      'C（粗利）
    ws.Cells(12, col1).Value = GetValue(HON3sheet, "I", "H", "4", HON3dicT, HON3Rows)      'D（数量）
    ws.Cells(12, col2).Value = GetValue(HON3sheet, "K", "H", "4", HON3dicT, HON3Rows)      'D（粗利）
    ws.Cells(13, col1).Value = GetValue(HON3sheet, "I", "H", "5", HON3dicT, HON3Rows)      'E（数量）
    ws.Cells(13, col2).Value = GetValue(HON3sheet, "K", "H", "5", HON3dicT, HON3Rows)      'E（粗利）
    ws.Cells(14, col1).Value = GetValue(HON3sheet, "I", "H", "6", HON3dicT, HON3Rows)      'F（数量）
    ws.Cells(14, col2).Value = GetValue(HON3sheet, "K", "H", "6", HON3dicT, HON3Rows)      'F（粗利）
    ws.Cells(15, col1).Value = GetValue(HON3sheet, "I", "H", "7", HON3dicT, HON3Rows)      'G（数量）
    ws.Cells(15, col2).Value = GetValue(HON3sheet, "K", "H", "7", HON3dicT, HON3Rows)      'G（粗利）
    ws.Cells(16, col1).Value = GetValue(HON3sheet, "I", "H", "8", HON3dicT, HON3Rows)      'H（数量）
    ws.Cells(16, col2).Value = GetValue(HON3sheet, "K", "H", "8", HON3dicT, HON3Rows)      'H（粗利）
    ws.Cells(17, col1).Value = GetValue(HON3sheet, "I", "H", "9", HON3dicT, HON3Rows)      'I（数量）
    ws.Cells(17, col2).Value = GetValue(HON3sheet, "K", "H", "9", HON3dicT, HON3Rows)      'I（粗利）
    ws.Cells(18, col1).Value = GetValue(HON3sheet, "J", "F", "10", HON3dicT, HON3Rows)      'J（数量）
    ws.Cells(18, col2).Value = GetValue(HON3sheet, "K", "F", "10", HON3dicT, HON3Rows)      'J（粗利）
    '1部集計
    ws.Cells(20, col1).Value = GetValue(HON1sheet, "I", "H", "1", HON1dicT, HON1Rows)     'K（数量）
    ws.Cells(20, col2).Value = GetValue(HON1sheet, "K", "H", "1", HON1dicT, HON1Rows)     'K（粗利）
    ws.Cells(21, col1).Value = GetValue(HON1sheet, "I", "H", "2", HON1dicT, HON1Rows)     'L（数量）
    ws.Cells(21, col2).Value = GetValue(HON1sheet, "K", "H", "2", HON1dicT, HON1Rows)     'L（粗利）
    ws.Cells(22, col1).Value = GetValue(HON1sheet, "I", "H", "3", HON1dicT, HON1Rows)     'M（数量）
    ws.Cells(22, col2).Value = GetValue(HON1sheet, "K", "H", "3", HON1dicT, HON1Rows)     'M（粗利）
    ws.Cells(23, col1).Value = GetValue(HON1sheet, "I", "H", "4", HON1dicT, HON1Rows)     'N（数量）
    ws.Cells(23, col2).Value = GetValue(HON1sheet, "K", "H", "4", HON1dicT, HON1Rows)     'N（粗利）
    ws.Cells(24, col1).Value = GetValue(HON1sheet, "I", "H", "5", HON1dicT, HON1Rows)     'O（数量）
    ws.Cells(24, col2).Value = GetValue(HON1sheet, "K", "H", "5", HON1dicT, HON1Rows)     'O（粗利）
    ws.Cells(26, col1).Value = GetValue(HON1sheet, "J", "F", "1", HON1dicT, HON1Rows)     'P（数量）
    ws.Cells(26, col2).Value = GetValue(HON1sheet, "K", "F", "1", HON1dicT, HON1Rows)     'P（粗利）
    ws.Cells(27, col1).Value = GetValue(HON1sheet, "J", "F", "2", HON1dicT, HON1Rows)     'Q（数量）
    ws.Cells(27, col2).Value = GetValue(HON1sheet, "K", "F", "2", HON1dicT, HON1Rows)     'Q（粗利）
    '2部集計
    ws.Cells(30, col1).Value = GetValue(HON2sheet, "F", "B", "4", HON2dicT, HON2Rows)     '1（数量）
    ws.Cells(30, col2).Value = GetValue(HON2sheet, "H", "B", "4", HON2dicT, HON2Rows)     '1（粗利）
    ws.Cells(31, col1).Value = GetValue(HON2sheet, "F", "B", "5", HON2dicT, HON2Rows)     '2（数量）
    ws.Cells(31, col2).Value = GetValue(HON2sheet, "H", "B", "5", HON2dicT, HON2Rows)     '2（粗利）
    ws.Cells(32, col1).Value = GetValue(HON2sheet, "G", "B", "6", HON2dicT, HON2Rows)     '3（数量）
    ws.Cells(32, col2).Value = GetValue(HON2sheet, "H", "B", "6", HON2dicT, HON2Rows)     '3（粗利）
End Sub
'ピボットシートから値を取得する
Private Function GetValue(ByVal sheet_name, ByVal g_col As String, ByVal col1 As String, ByVal val1 As Variant, ByVal dicT As Object, ByRef TRows() As Long) As Variant
    Dim ix As Long
    Dim j, row, ctr As Long
    Dim gval As Variant 'PVシートから取得した集計対象値
    Dim gval1 As Variant 'PVシートから取得した条件値
    GetValue = Empty '取得値初期化
    '担当者のデータがないなら終了
    If dicT.exists(trg_key) = False Then Exit Function
    '担当者の添字とシート名を決定
    ix = dicT(trg_key)
    ctr = TRows(ix, 0)
    '該当する行の数ぶん繰り返す
    For j = 1 To ctr
        row = TRows(ix, j) '行番号取得
        '値を取得する
        gval = Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, g_col).Value
         '取得値が空白でなく、かつ、取得条件が成立するなら、加算する
        If gval <> "" Then
            '取得したデータが数字でない場合は、エラー表示後、処理を打ち切る
            If IsNumeric(gval) = False Then
                MsgBox ("不正データ検出。以下のデータを正しく修正して下さい。処理を打ち切ります。")
                MsgBox ("ブック名[" & Uri_book & "] シート名(" & sheet_name & ")" & " 行番号=" & row & " 列=" & g_col)
                MsgBox (gval)
                Workbooks(Uri_book).Activate
                Workbooks(Uri_book).Worksheets(sheet_name).Activate
                Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, g_col).Select
                End
            End If
            '条件の値を取得
            gval1 = Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, col1).Text
            '条件が成立するなら加算する
            If gval1 = val1 Then
                GetValue = GetValue + gval
            End If
        End If
     Next
 End Function
'ピボットテーブル読み込み
Private Sub readPivot(ByVal sheet_name As String, ByVal dicT As Object, ByRef TRows() As Long)
    Dim index As Long
    Dim sh As Worksheet
    Dim maxrow, row As Long
    Dim dmonth, key As String
    index = 0
    dmonth = trg_mm & "月"
    Set sh = Worksheets(sheet_name)
    maxrow = sh.Cells(Rows.count, "A").End(xlUp).row 'Sheet1 A列最大行
    '3行から最終行まで繰り返す
    For row = 3 To maxrow
        '集計月に一致するなら、テーブルに格納する（集計年は今のところ使用しない）
        If sh.Cells(row, "A").Text = dmonth Then
            '支店名＋課名＋担当者名
            key = sh.Cells(row, "D").Value & "|" & sh.Cells(row, "E").Value & "|" & sh.Cells(row, "C").Value
            Call add_table(sheet_name, dicT, TRows, index, row, key)
        End If
    Next
End Sub
'テーブル登録
Private Sub add_table(ByVal sheet_name As String, ByVal dicT As Object, ByRef TRows() As Long, ByRef index As Long, ByVal row, ByVal key As String)
    Dim i, j As Long
    If dicT.exists(key) = True Then
        i = dicT(key)
        j = TRows(i, 0)
        j = j + 1
        If j > Rmax Then
            MsgBox (sheet_name & "で1人のひと月の最大行数オーバー Rmaxを大きくしてください。Rmax=" & Rmax)
            End
        End If
        TRows(i, 0) = j
        TRows(i, j) = row
    Else
        If index > Pmax Then
            MsgBox (sheet_name & "で従業員の最大数オーバー Pmaxを大きくしてください。Pmax=" & Pmax)
            End
        End If
        dicT(key) = index
        TRows(index, 0) = 1
        TRows(index, 1) = row
        index = index + 1
    End If
End Sub
'指定月から指定月対応のカラム位置（計画数量）を計算する
'カラム位置は1からの連番
'10月=4 ... 9月=184
Private Function GetColNumber(ByVal mm As Long)
    Dim x, ix As Long
    If mm < 10 Then mm = mm + 12
    x = mm - 10
    ix = x + x \ 3 + x \ 6
    GetColNumber = 4 + 12 * ix
End Function
'ピボット情報を出力する
Private Sub OutPivot()
    Call OutPivotUnit("1部", HON1dicT, HON1Rows)
    Call OutPivotUnit("2部", HON2dicT, HON2Rows)
    Call OutPivotUnit("3部", HON3dicT, HON3Rows)
End Sub
'部単位でピボット情報を出力する
Private Sub OutPivotUnit(ByVal sheetName As String, ByVal dicT As Object, ByRef TRows() As Long)
    Dim ws As Worksheet
    Dim key As Variant
    Dim row, col, ix, ctr, i, gno As Long
    ThisWorkbook.Activate
    Set ws = Worksheets(sheetName)
    ws.Cells.Clear
    row = 0
    '全てのキーを処理する
    For Each key In dicT
        ix = dicT(key)
        row = row + 1
        'キー印字
        ws.Cells(row, 1).Value = key
        ctr = TRows(ix, 0)
        '行番号印字
        For i = 1 To ctr
            gno = TRows(ix, i)
            col = i + 1
            ws.Cells(row, col).Value = gno
        Next
    Next
End Sub
 

Option Explicit
    Const Pmax As Long = 100    '従業員人の最大数
    Const Rmax As Long = 600    '1ピボットシート内の1人のひと月の最大行数

    Dim HON1Rows(Pmax, Rmax) As Long  '本年1部の行情報
    '                                   左側の添字＝各個人に割当られた番号(0-100)
    '                                   右側の添字＝0番目は以降の要素数を示す。（例 この値が3の時、要素数3なので、3番目の添字まで有効）
    '                                   右側の添字＝1番目以降は、行番号を示す。
    Dim HON2Rows(Pmax, Rmax) As Long  '本年2部の行情報（添字は本年1部と同様）
    Dim HON3Rows(Pmax, Rmax) As Long  '本年3部の行情報（添字は本年1部と同様）
    Dim HON1dicT As Object            '本年1部の辞書　キー：支店名＋課名＋個人名 値：行情報テーブルの添字(0-100)
    Dim HON2dicT As Object            '本年2部の辞書 （キーと値は本年1部と同様）
    Dim HON3dicT As Object            '本年3部の辞書 （キーと値は本年1部と同様）
    Const HON1sheet As String = "1部本年P"
    Const HON2sheet As String = "2部本年P"
    Const HON3sheet As String = "3部本年P"
    Const JISSEKI As String = "実績"           '実績
    Const ZENNEN  As String = "前年"           '前年
    Dim Uri_book As String              '売上明細データブック名
    Dim trg_yyyy As Long                '指定年
    Dim trg_mm As Long                  '指定月
    Dim Jis_folder As String            '実績フォルダ
    Dim Kei_folder As String            '計画フォルダ
    Dim trg_key As String               '個人名キー
    Dim trg_col As Long                 '算出カラム番号
    Dim trg_mode As String              '実績/前年
    Dim warnP As String                 '警告従業員
Public Sub 売上月単位集計()
    Dim ws As Worksheet
    Dim yyyy, mm, ext As Variant
    Dim t1, t2 As Variant
    Dim Uri_path As String
    Set HON1dicT = CreateObject("Scripting.Dictionary")
    Set HON2dicT = CreateObject("Scripting.Dictionary")
    Set HON3dicT = CreateObject("Scripting.Dictionary")
    Set ws = Worksheets("管理")
    yyyy = ws.Cells(2, "A").Value               '集計年
    If yyyy = "" Or IsNumeric(yyyy) = False Then
        MsgBox ("集計年月が不正")
        Exit Sub
    End If
    trg_yyyy = yyyy
    If trg_yyyy < 2010 Or trg_yyyy > 2099 Then
        MsgBox ("集計年月(2010-2099)が範囲外")
        Exit Sub
    End If
    mm = ws.Cells(2, "B").Value                 '集計月
    If mm = "" Or IsNumeric(mm) = False Then
        MsgBox ("集計月が不正")
        Exit Sub
    End If
    trg_mm = mm
    If trg_mm < 1 Or trg_mm > 12 Then
        MsgBox ("集計月(1-12)が範囲外")
        Exit Sub
    End If
    trg_mode = ws.Cells(2, "C").Value           '集計項目
    If trg_mode <> JISSEKI And trg_mode <> ZENNEN Then
        MsgBox ("集計項目が不正")
        Exit Sub
    End If
    Jis_folder = ws.Cells(2, "D").Value            '実績フォルダ名
    Uri_book = ws.Cells(2, "E").Value              '実績売上明細ファイル
    '拡張子のチェック
    ext = Right(LCase(Uri_book), 5)
    If ext <> ".xlsx" And ext <> ".xlsm" Then
        MsgBox ("実績ファイル名が不正")
        Exit Sub
    End If
    Kei_folder = ws.Cells(2, "F").Value            '計画フォルダ名
    
    If Dir(Jis_folder, vbDirectory) = "" Then
        MsgBox ("実績フォルダが存在しません<" & Jis_folder & ">")
        Exit Sub
    End If
    If Dir(Kei_folder, vbDirectory) = "" Then
        MsgBox ("計画フォルダが存在しません<" & Kei_folder & ">")
        Exit Sub
    End If
    '売上明細ブック名設定
    Uri_path = Jis_folder & "\" & Uri_book
    'MsgBox ("ファイル名<" & Uri_book & ">") '追加①
    'MsgBox ("フルパス名<" & Uri_path & ">") '追加②
    'MsgBox (GetAttr(Uri_path)) '追加③
    If Dir(Uri_path) = "" Then
        MsgBox (Uri_path & "が存在しません")
        Exit Sub
    End If

    If MsgBox(trg_yyyy & "年" & trg_mm & "月の" & trg_mode & "を" & Uri_book & "から集計します", vbOKCancel) <> vbOK Then Exit Sub
    t1 = Timer
    warnP = ""
    Application.ScreenUpdating = False
    '売上明細ブック名オープン
    Workbooks.Open Uri_path
    Workbooks(Uri_book).Activate
    'ピボットデータ読み込み
    Call readPivot(HON1sheet, HON1dicT, HON1Rows)
    Call readPivot(HON2sheet, HON2dicT, HON2Rows)
    Call readPivot(HON3sheet, HON3dicT, HON3Rows)
    Call OutPivot 'ピボット情報出力・・・・・追加①
    '計画フォルダ内の全ブックを更新する
    Call UpdateAllBooks(Kei_folder)
    Workbooks(Uri_book).Close
    Application.ScreenUpdating = True
    t2 = Timer
    MsgBox ("処理完了 所要時間(秒)=" & t2 - t1)
    If warnP <> "" Then
        MsgBox ("下記従業員は、1部,2部,3部の何れのピボットにも集計月のデータなし。" & vbLf & warnP)
    End If
End Sub

'計画フォルダ内の全てのブックを更新する
Private Sub UpdateAllBooks(ByVal Kei_folder As String)
    Dim bookname As String
    bookname = Dir(Kei_folder & "\*.xlsx", vbNormal)
    If bookname = "" Then
        MsgBox (Kei_folder & "内に支店別＆課別（個人データ）ブックが存在しません。")
        End
    End If
    '全てのブックを更新する
    Do While bookname <> ""
        Call Update1Book(Kei_folder, bookname)
        bookname = Dir()
    Loop
End Sub

'１つのブックを更新する
Private Sub Update1Book(ByVal Kei_folder As String, ByVal bookname As String)
    Dim ws As Worksheet
    Dim i As Long
    Workbooks.Open Kei_folder & "\" & bookname
    '左側のシートから順に処理する
    For i = 1 To Worksheets.count
        Set ws = Worksheets(i)
        '合計シート検出時、終了
        If ws.name = "合計" Then Exit For
        If ws.name = "拠点計" Then Exit For '追加②
        '１つのシートを更新する
        Call Update1Sheet(bookname, ws)
    Next
    'ブックを保存し、閉じる
    Workbooks(bookname).Save
    Workbooks(bookname).Close
End Sub
'１つのシートを更新する
Private Sub Update1Sheet(ByVal bookname As String, ByVal ws As Worksheet)
    '支店名＋課名＋担当者名
    trg_key = ws.Cells(2, "C").Value & "|" & ws.Cells(3, "C").Value & "|" & ws.Cells(4, "C").Value
    '1部,2部,3部のピボットシート内に担当者の集計月の行が１件もない場合は、警告メッセージを出力し、その担当者をスキップする
    If HON1dicT.exists(trg_key) = False And HON2dicT.exists(trg_key) = False And HON3dicT.exists(trg_key) = False Then
        warnP = warnP & bookname & "(" & ws.name & ")" & trg_key & vbLf
    End If
    '集計月に対応するカラム位置を取得
    trg_col = GetColNumber(trg_mm)
    '個人シートに値を設定する
    Call set_value(bookname, ws, trg_mode)
End Sub
'個人シートに値の設定を行う
Private Sub set_value(ByVal bookname As String, ByVal ws As Worksheet, ByVal mode As String)
    Dim col1 As Long    '数量のカラム位置
    Dim col2 As Long    '粗利のカラム位置
    'カラム位置の設定
    col1 = trg_col + 3
    col2 = trg_col + 8
    '実績（当年）の場合は1カラム右へ設定
    If mode = JISSEKI Then
        col1 = col1 + 1
        col2 = col2 + 1
    End If
    '3部集計
    '                                 PVシート名,取得列,条件列,条件値,PV辞書,PV行情報
    ws.Cells(9, col1).Value = GetValue(HON3sheet, "I", "H", "1", HON3dicT, HON3Rows)      'A（数量）
    ws.Cells(9, col2).Value = GetValue(HON3sheet, "K", "H", "1", HON3dicT, HON3Rows)      'A（粗利）
    ws.Cells(10, col1).Value = GetValue(HON3sheet, "I", "H", "2", HON3dicT, HON3Rows)      'B（数量）
    ws.Cells(10, col2).Value = GetValue(HON3sheet, "K", "H", "2", HON3dicT, HON3Rows)      'B（粗利）
    ws.Cells(11, col1).Value = GetValue(HON3sheet, "I", "H", "3", HON3dicT, HON3Rows)      'C（数量）
    ws.Cells(11, col2).Value = GetValue(HON3sheet, "K", "H", "3", HON3dicT, HON3Rows)      'C（粗利）
    ws.Cells(12, col1).Value = GetValue(HON3sheet, "I", "H", "4", HON3dicT, HON3Rows)      'D（数量）
    ws.Cells(12, col2).Value = GetValue(HON3sheet, "K", "H", "4", HON3dicT, HON3Rows)      'D（粗利）
    ws.Cells(13, col1).Value = GetValue(HON3sheet, "I", "H", "5", HON3dicT, HON3Rows)      'E（数量）
    ws.Cells(13, col2).Value = GetValue(HON3sheet, "K", "H", "5", HON3dicT, HON3Rows)      'E（粗利）
    ws.Cells(14, col1).Value = GetValue(HON3sheet, "I", "H", "6", HON3dicT, HON3Rows)      'F（数量）
    ws.Cells(14, col2).Value = GetValue(HON3sheet, "K", "H", "6", HON3dicT, HON3Rows)      'F（粗利）
    ws.Cells(15, col1).Value = GetValue(HON3sheet, "I", "H", "7", HON3dicT, HON3Rows)      'G（数量）
    ws.Cells(15, col2).Value = GetValue(HON3sheet, "K", "H", "7", HON3dicT, HON3Rows)      'G（粗利）
    ws.Cells(16, col1).Value = GetValue(HON3sheet, "I", "H", "8", HON3dicT, HON3Rows)      'H（数量）
    ws.Cells(16, col2).Value = GetValue(HON3sheet, "K", "H", "8", HON3dicT, HON3Rows)      'H（粗利）
    ws.Cells(17, col1).Value = GetValue(HON3sheet, "I", "H", "9", HON3dicT, HON3Rows)      'I（数量）
    ws.Cells(17, col2).Value = GetValue(HON3sheet, "K", "H", "9", HON3dicT, HON3Rows)      'I（粗利）
    ws.Cells(18, col1).Value = GetValue(HON3sheet, "J", "F", "10", HON3dicT, HON3Rows)      'J（数量）
    ws.Cells(18, col2).Value = GetValue(HON3sheet, "K", "F", "10", HON3dicT, HON3Rows)      'J（粗利）
    '1部集計
    ws.Cells(20, col1).Value = GetValue(HON1sheet, "I", "H", "1", HON1dicT, HON1Rows)     'K（数量）
    ws.Cells(20, col2).Value = GetValue(HON1sheet, "K", "H", "1", HON1dicT, HON1Rows)     'K（粗利）
    ws.Cells(21, col1).Value = GetValue(HON1sheet, "I", "H", "2", HON1dicT, HON1Rows)     'L（数量）
    ws.Cells(21, col2).Value = GetValue(HON1sheet, "K", "H", "2", HON1dicT, HON1Rows)     'L（粗利）
    ws.Cells(22, col1).Value = GetValue(HON1sheet, "I", "H", "3", HON1dicT, HON1Rows)     'M（数量）
    ws.Cells(22, col2).Value = GetValue(HON1sheet, "K", "H", "3", HON1dicT, HON1Rows)     'M（粗利）
    ws.Cells(23, col1).Value = GetValue(HON1sheet, "I", "H", "4", HON1dicT, HON1Rows)     'N（数量）
    ws.Cells(23, col2).Value = GetValue(HON1sheet, "K", "H", "4", HON1dicT, HON1Rows)     'N（粗利）
    ws.Cells(24, col1).Value = GetValue(HON1sheet, "I", "H", "5", HON1dicT, HON1Rows)     'O（数量）
    ws.Cells(24, col2).Value = GetValue(HON1sheet, "K", "H", "5", HON1dicT, HON1Rows)     'O（粗利）
    ws.Cells(26, col1).Value = GetValue(HON1sheet, "J", "F", "1", HON1dicT, HON1Rows)     'P（数量）
    ws.Cells(26, col2).Value = GetValue(HON1sheet, "K", "F", "1", HON1dicT, HON1Rows)     'P（粗利）
    ws.Cells(27, col1).Value = GetValue(HON1sheet, "J", "F", "2", HON1dicT, HON1Rows)     'Q（数量）
    ws.Cells(27, col2).Value = GetValue(HON1sheet, "K", "F", "2", HON1dicT, HON1Rows)     'Q（粗利）
    '2部集計
    ws.Cells(30, col1).Value = GetValue(HON2sheet, "F", "B", "4", HON2dicT, HON2Rows)     '1（数量）
    ws.Cells(30, col2).Value = GetValue(HON2sheet, "H", "B", "4", HON2dicT, HON2Rows)     '1（粗利）
    ws.Cells(31, col1).Value = GetValue(HON2sheet, "F", "B", "5", HON2dicT, HON2Rows)     '2（数量）
    ws.Cells(31, col2).Value = GetValue(HON2sheet, "H", "B", "5", HON2dicT, HON2Rows)     '2（粗利）
    ws.Cells(32, col1).Value = GetValue(HON2sheet, "G", "B", "6", HON2dicT, HON2Rows)     '3（数量）
    ws.Cells(32, col2).Value = GetValue(HON2sheet, "H", "B", "6", HON2dicT, HON2Rows)     '3（粗利）
End Sub
'ピボットシートから値を取得する
Private Function GetValue(ByVal sheet_name, ByVal g_col As String, ByVal col1 As String, ByVal val1 As Variant, ByVal dicT As Object, ByRef TRows() As Long) As Variant
    Dim ix As Long
    Dim j, row, ctr As Long
    Dim gval As Variant 'PVシートから取得した集計対象値
    Dim gval1 As Variant 'PVシートから取得した条件値
    GetValue = Empty '取得値初期化
    '担当者のデータがないなら終了
    If dicT.exists(trg_key) = False Then Exit Function
    '担当者の添字とシート名を決定
    ix = dicT(trg_key)
    ctr = TRows(ix, 0)
    '該当する行の数ぶん繰り返す
    For j = 1 To ctr
        row = TRows(ix, j) '行番号取得
        '値を取得する
        gval = Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, g_col).Value
         '取得値が空白でなく、かつ、取得条件が成立するなら、加算する
        If gval <> "" Then
            '取得したデータが数字でない場合は、エラー表示後、処理を打ち切る
            If IsNumeric(gval) = False Then
                MsgBox ("不正データ検出。以下のデータを正しく修正して下さい。処理を打ち切ります。")
                MsgBox ("ブック名[" & Uri_book & "] シート名(" & sheet_name & ")" & " 行番号=" & row & " 列=" & g_col)
                MsgBox (gval)
                Workbooks(Uri_book).Activate
                Workbooks(Uri_book).Worksheets(sheet_name).Activate
                Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, g_col).Select
                End
            End If
            '条件の値を取得
            gval1 = Workbooks(Uri_book).Worksheets(sheet_name).Cells(row, col1).Text
            '条件が成立するなら加算する
            If gval1 = val1 Then
                GetValue = GetValue + gval
            End If
        End If
     Next
 End Function
'ピボットテーブル読み込み
Private Sub readPivot(ByVal sheet_name As String, ByVal dicT As Object, ByRef TRows() As Long)
    Dim index As Long
    Dim sh As Worksheet
    Dim maxrow, row As Long
    Dim dmonth, key As String
    index = 0
    dmonth = trg_mm & "月"
    Set sh = Worksheets(sheet_name)
    maxrow = sh.Cells(Rows.count, "A").End(xlUp).row 'Sheet1 A列最大行
    '3行から最終行まで繰り返す
    For row = 3 To maxrow
        '集計月に一致するなら、テーブルに格納する（集計年は今のところ使用しない）
        If sh.Cells(row, "A").Text = dmonth Then
            '支店名＋課名＋担当者名
            key = sh.Cells(row, "D").Value & "|" & sh.Cells(row, "E").Value & "|" & sh.Cells(row, "C").Value
            Call add_table(sheet_name, dicT, TRows, index, row, key)
        End If
    Next
End Sub
'テーブル登録
Private Sub add_table(ByVal sheet_name As String, ByVal dicT As Object, ByRef TRows() As Long, ByRef index As Long, ByVal row, ByVal key As String)
    Dim i, j As Long
    If dicT.exists(key) = True Then
        i = dicT(key)
        j = TRows(i, 0)
        j = j + 1
        If j > Rmax Then
            MsgBox (sheet_name & "で1人のひと月の最大行数オーバー Rmaxを大きくしてください。Rmax=" & Rmax)
            End
        End If
        TRows(i, 0) = j
        TRows(i, j) = row
    Else
        If index > Pmax Then
            MsgBox (sheet_name & "で従業員の最大数オーバー Pmaxを大きくしてください。Pmax=" & Pmax)
            End
        End If
        dicT(key) = index
        TRows(index, 0) = 1
        TRows(index, 1) = row
        index = index + 1
    End If
End Sub
'指定月から指定月対応のカラム位置（計画数量）を計算する
'カラム位置は1からの連番
'10月=4 ... 9月=184
Private Function GetColNumber(ByVal mm As Long)
    Dim x, ix As Long
    If mm < 10 Then mm = mm + 12
    x = mm - 10
    ix = x + x \ 3 + x \ 6
    GetColNumber = 4 + 12 * ix
End Function
'ピボット情報を出力する
Private Sub OutPivot()
    Call OutPivotUnit("1部", HON1dicT, HON1Rows)
    Call OutPivotUnit("2部", HON2dicT, HON2Rows)
    Call OutPivotUnit("3部", HON3dicT, HON3Rows)
End Sub
'部単位でピボット情報を出力する
Private Sub OutPivotUnit(ByVal sheetName As String, ByVal dicT As Object, ByRef TRows() As Long)
    Dim ws As Worksheet
    Dim key As Variant
    Dim row, col, ix, ctr, i, gno As Long
    ThisWorkbook.Activate
    Set ws = Worksheets(sheetName)
    ws.Cells.Clear
    row = 0
    '全てのキーを処理する
    For Each key In dicT
        ix = dicT(key)
        row = row + 1
        'キー印字
        ws.Cells(row, 1).Value = key
        ctr = TRows(ix, 0)
        '行番号印字
        For i = 1 To ctr
            gno = TRows(ix, i)
            col = i + 1
            ws.Cells(row, col).Value = gno
        Next
    Next
End Sub
