Overview

Classes

  • mapdb
  • webservice
  • Overview
  • Class
  • Tree
   1: <?php
   2: /* mode inject */
   3: define("MODE_INJECT_INDIVIDU", 1);
   4: define("MODE_INJECT_MASSAL", 2);
   5: define("MODE_INJECT_GAGAL", 3);
   6:     
   7: require_once ("lib/nusoap.php");
   8: require_once ("lib/class.wsdlcache.php");
   9: 
  10: /** 
  11:  * webservice.inc.php
  12:  * <br/> kelas webservice: untuk mengambil data dari PDDIKTI atau menyimpan data ke PDDIKTI, disinkronkan dengan database institusi
  13:  * <br/> profil  https://id.linkedin.com/in/basitadhi
  14:  * <br/> buat    2015-10-30
  15:  * <br/> rev     2017-03-01
  16:  * <br/> sifat   open source
  17:  * @author Basit Adhi Prabowo, S.T. <basit@unisayogya.ac.id>
  18:  * @access public
  19:  */
  20: class webservice
  21: {
  22:   var $proxy;           /* proxy koneksi webservice PDDIKTI */
  23:   var $pddikti;         /* setting PDDIKTI */
  24:   var $institusi;       /* setting institusi */
  25:   var $sekarang;        /* waktu saat ini */
  26:   var $debug;           /* mode debug */
  27:   var $status;          /* status webservice PDDIKTI */
  28:   var $mapdb;           /* pemetaan field basis data institusi dengan PDDIKTI */
  29:   var $db;              /* basis data institusi */
  30:   var $nbaris_tabel;    /* jumlah baris pada tabel */
  31: 
  32: /*vv koneksi WEBSERVICE PDDIKTI vv*/
  33: 
  34:   /**
  35:    * konstruktor kelas webservice, dieksekusi ketika objek dibuat
  36:    * @param type $pddikti
  37:    * - setting webservice PDDIKTI (config.ini.php)
  38:    * @param type $institusi
  39:    * - setting basis data institusi (config.ini.php)
  40:    * @param type $debug jika ya, maka akan lebih banyak pesan yang akan ditampilkan
  41:    * - mode debug?
  42:    */
  43:   function webservice($pddikti, $institusi, $debug=false)
  44:   {
  45:     /* mulai buffer output, untuk menghemat memory */
  46:     ob_start();
  47:     /* ubah setting maksimal waktu tunggu eksekusi */
  48:     set_time_limit(EXECUTION_TIME_LIMIT);
  49:     /* awalan */
  50:     $this->pddikti    = $pddikti;
  51:     $this->institusi  = $institusi;
  52:     $this->debug      = $debug;
  53:     $this->status     = array("status" => true, "pesankesalahan" => "");
  54:     /* tampilkan pesan debug apabila dalam mode debug */
  55:     if ($this->debug)
  56:     {
  57:       echo $this->mode();
  58:       $this->print_r_rapi($this->pddikti);
  59:     }
  60:     /* persiapan proses */
  61:     $this->persiapan();
  62:     /* memeriksa status webservice PDDIKTI */
  63:     $this->periksa();
  64:   }
  65: 
  66:   /**
  67:    * destruktor kelas webservice, dieksekusi ketika objek dihancurkan
  68:    */
  69:   function __destruct()
  70:   {
  71:     /* tampilkan pesan debug apabila dalam mode debug */
  72:     if ($this->debug) 
  73:     {
  74:         echo "Bersih-bersih";
  75:     }
  76:     /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
  77:     $this->kirim_buffer();
  78:     /* bersih-bersih */
  79:     unset($this->proxy);
  80:     unset($this->pddikti);
  81:     unset($this->institusi);
  82:     unset($this->now);
  83:     unset($this->debug);
  84:     unset($this->status);
  85:     unset($this->mapdb);
  86:     unset($this->db);
  87:     /* mengakhiri buffer output */
  88:     ob_end_clean();
  89:   }
  90: 
  91:   /**
  92:    * mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer
  93:    */
  94:   function kirim_buffer()
  95:   {
  96:     ob_flush();
  97:     flush();
  98:   }
  99: 
 100:   /**
 101:    *  persiapan proses 
 102:    */
 103:   function persiapan()
 104:   {
 105:     /* koneksi ke webservice PDDIKTI */
 106:     $this->terhubung_proxy();
 107:     /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 108:     $this->penokenan();
 109:   }
 110: 
 111:   /**
 112:    * memeriksa apakah server error atau tidak.
 113:    * <br/> sumber: http://www.thecave.info/php-ping-script-to-check-remote-server-or-website/
 114:    * @param type $host
 115:    * - alamat host yang akan di ping
 116:    * @param type $port
 117:    * - port yang akan di ping - OPTIONAL, default: 80
 118:    * @param type $waktutunggu
 119:    * - waktu yang diberikan untuk menandai bahwa server error (dalam detik) - OPSIONAL, default: 6
 120:    * @return boolean
 121:    * - true: terkoneksi, false: error
 122:    */
 123:   function ping($host,$port=80,$waktutunggu=6)
 124:   {
 125:     /* tidak diperbolehkan ada http:// pada host, sehingga perlu dihilangkan (jika ada) */
 126:     $fsock = fsockopen(str_replace("http://", "", $host), $port, $errno = 0, $errstr = "", $waktutunggu);
 127:     /* jika koneksi error */
 128:     if ( ! $fsock )
 129:     {
 130:       fclose($fsock);
 131:       return false;
 132:     }
 133:     /* terkoneksi */
 134:     else
 135:     {
 136:       fclose($fsock);
 137:       return true;
 138:     }
 139:   }
 140: 
 141:   /**
 142:    *  koneksi ke webservice PDDIKTI
 143:    */
 144:   function terhubung_proxy()
 145:   {
 146:     /* melakukan koneksi webservice PDDIKTI sesuai dengan setting pada config.ini.php */
 147:     $klien = new nusoap_client($this->pddikti["ws"]["url"], true);
 148:     /* apabila server PDDIKTI mati, maka akan muncul pesan error dan tidak bisa melakukan aksi apapun */
 149:     if (!$this->ping($this->pddikti["ws"]["host"], $this->pddikti["ws"]["port"]))
 150:     {
 151:       $this->status = array("status" => false, "pesankesalahan" => "Terjadi kegagalan koneksi. Apakah server FEEDER DIKTI mati?");
 152:     }
 153:     /* simpan informasi koneksi */
 154:     else
 155:     {
 156:       $this->pddikti["proxy"] = $klien->getProxy();
 157:     }
 158:     /* bersih-bersih */
 159:     unset($klien);
 160:   }
 161:   
 162:   /**
 163:     * menampilkan mode FEEDER PDDIKTI ke browser
 164:     * @global array $pddikti
 165:     * - setting koneksi PDDIKTI
 166:     * @return type
 167:     * - mode
 168:     */
 169:    function mode()
 170:    {
 171:      return "Mode saat ini adalah ".(($this->pddikti["ws"]["mode"]==MODE_SANDBOX)?"sandbox (percobaan)":"live (langsung)")."<br />";
 172:    }
 173: 
 174:   /**
 175:    *  menjamin keberadaan token, meminta token kembali apabila sudah expire
 176:    */
 177:   function penokenan()
 178:   {
 179:     if ($this->status_periksa())
 180:     {
 181:        /* set waktu saat ini */
 182:        $this->now = date('Y-m-d H:i:s');
 183:        /* jika sesi belum terbentuk atau sudah melewati masa expire */
 184:        if ($_SESSION["expire"] == "" || $_SESSION["expire"] < $this->now)
 185:        {
 186:          /* token digenerate ulang jika sudah melewati masa expire */
 187:          if ($_SESSION["expire"] < $this->now)
 188:          {
 189:              /* mendapatkan token webservice PDDIKTI */
 190:              $_SESSION["token"]  = $this->token();
 191:          }
 192:          /* menentukan waktu untuk generate ulang token, pengaman 2 menit */
 193:          $_SESSION["expire"] = date('Y-m-d H:i:s', strtotime($this->now) + $this->pddikti["ws"]["expire"] - 120);
 194:        }
 195:        /* tampilkan pesan debug apabila dalam mode debug */
 196:        if ($this->debug) 
 197:        {
 198:            $this->print_r_rapi($_SESSION);
 199:        }
 200:      }
 201:   }
 202: 
 203:   /**
 204:    * mendapatkan token webservice PDDIKTI
 205:    * @return type
 206:    * - token PDDIKTI
 207:    */
 208:   function token()
 209:   {
 210:     /* token */
 211:     return $this->pddikti["proxy"]->getToken($this->pddikti["login"]["username"], $this->pddikti["login"]["password"]);
 212:   }
 213: 
 214:   /**
 215:    * memeriksa status koneksi FEEDER DIKTI
 216:    * @return type
 217:    * - true: terkoneksi, false: error
 218:    */
 219:   function status_periksa()
 220:   {
 221:     if (!$this->status["status"])
 222:     {
 223:       echo "<br />".$this->status["pesankesalahan"];
 224:     }
 225:     return $this->status["status"];
 226:   }
 227: 
 228:   /**
 229:    * memeriksa status webservice PDDIKTI
 230:    */
 231:   function periksa()
 232:   {
 233:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 234:     if ($this->status_periksa())
 235:     {
 236:       /* mendapatkan versi dari webservice PDDIKTI (dan pesan error, jika ada) */
 237:       $hasil       = $this->GetVersion();
 238:       /* memberikan status (flag) dan pesan error (message) */
 239:       $this->status = (($hasil["error_code"] == 104)?array("status" => false, "pesankesalahan" => "Webservice sudah expired. Pastikan server tidak di belakang Proxy, selanjutnya ikuti petunjuk yang ada pada manual FEEDER DIKTI"):array("status" => true, "pesankesalahan" => ""));
 240:       /* jika status gagal, maka nilai sesi expire dibuat masa lampau */
 241:       if (!$this->status_periksa())
 242:       {
 243:         $_SESSION["expire"]  = '2010-01-01 00:00:00';
 244:       }
 245:       /* bersih-bersih */
 246:       unset($hasil);
 247:       /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
 248:       $this->kirim_buffer();
 249:     }
 250:   }
 251: 
 252:   /**
 253:    * set nilai pada mapdb (mapping.inc.php)
 254:    * @param type $mapdb
 255:    * - mapdb pada mapping.inc.php
 256:    */
 257:   function setMapdb($mapdb)
 258:   {
 259:     $this->mapdb  = $mapdb;
 260:     /* tampilkan pesan debug apabila dalam mode debug */
 261:     if ($this->debug)
 262:     {
 263:         $this->print_r_rapi($this->mapdb);
 264:     }
 265:   }
 266: 
 267: /*^^ koneksi WEBSERVICE PDDIKTI ^^*/
 268: 
 269: /*vv WEBSERVICE PDDIKTI vv*/
 270: 
 271:   /**
 272:    * mendapatkan deskripsi tabel dari webservice PDDIKTI (equal: desc [table]) yang terdaftar di dalam ListTable()
 273:    */
 274:   function GetDictionary_SemuaTabel()
 275:   {
 276:     /* mendapatkan daftar tabel dari webservice PDDIKTI (equal: show [table]) */
 277:     $daftarTabel  = $this->ListTable();
 278:     /* mencetak daftar tabel */
 279:     echo "<h1>Daftar Tabel</h1>";
 280:     /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
 281:     $this->cetak_tabel_parsial_mulai();
 282:     /* mencetak header, diambil dari indeks */
 283:     $this->cetak_tabel_parsial_indeks($daftarTabel["result"]);
 284:     /* mencetak daftar tabel */
 285:     foreach ($daftarTabel["result"] as $idx => $data)
 286:     {
 287:       $this->cetak_tabel_parsial($data);
 288:     }
 289:     /* menutup tabel terpisah */
 290:     $this->cetak_tabel_parsial_akhiri();
 291:     /* mencetak deskripsi tabel */
 292:     reset($daftarTabel["result"]);
 293:     foreach ($daftarTabel["result"] as $idx => $data)
 294:     {
 295:       echo "<h2>Deskripsi Tabel ".$data["table"]."</h2>";
 296:       /* ambil data deskripsi per tabel */
 297:       $deskripsiTabel  = $this->GetDictionary($data["table"]);
 298:       /* menyamakan kolom data tabel */
 299:       $deskripsiTabel["result"]  = $this->array_auto_fill($deskripsiTabel["result"]);
 300:       /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
 301:       $this->cetak_tabel_parsial_mulai();
 302:       /* mencetak header, diambil dari indeks */
 303:       $this->cetak_tabel_parsial_indeks($deskripsiTabel["result"]);
 304:       /* mencetak deskripsi tabel */
 305:       foreach ($deskripsiTabel["result"] as $data_)
 306:       {
 307:         $this->cetak_tabel_parsial($data_);
 308:       }
 309:       /* menutup tabel terpisah */
 310:       $this->cetak_tabel_parsial_akhiri();
 311:       /**/
 312:       unset($deskripsiTabel);
 313:     }
 314:     /* bersih-bersih */
 315:     unset($daftarTabel);
 316:   }
 317:   
 318:   /**
 319:    * mendapatkan daftar tabel dari webservice PDDIKTI (equal: show [table])
 320:    * @return type
 321:    * - daftar tabel
 322:    */
 323:   function ListTable()
 324:   {
 325:     /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 326:     $this->penokenan();
 327:     /* daftar tabel */
 328:     return $this->pddikti["proxy"]->ListTable($_SESSION["token"]);
 329:   }
 330: 
 331:   /**
 332:    * mendapatkan deskripsi tabel dari webservice PDDIKTI (equal: desc [table])
 333:    * @param type $tabel
 334:    * - tabel yang akan dilihat deskripsinya
 335:    * @return type
 336:    * - deskripsi tabel
 337:    */
 338:   function GetDictionary($tabel)
 339:   {
 340:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 341:     if ($this->status_periksa())
 342:     {
 343:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 344:       $this->penokenan();
 345:       /* deskripsi tabel */
 346:       return $this->pddikti["proxy"]->GetDictionary($_SESSION["token"], $tabel);
 347:     }
 348:   }
 349: 
 350:   /**
 351:    * mendapatkan satu baris data dari webservice PDDIKTI (equal: select * from [table] where [filter] limit 0, 1). 
 352:    * <br/> catatan: jika tidak muncul, tambahkan alias pada field di filter, misal: p.field atau gunakan nama_tabel.raw
 353:    * @param type $tabel
 354:    * - tabel (PDDIKTI) di mana data disimpan
 355:    * @param type $filter
 356:    * - filter data yang akan diambil - OPSIONAL, default: ""
 357:    * @return type
 358:    * - satu baris data
 359:    */
 360:   function GetRecord($tabel, $filter="")
 361:   {
 362:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 363:     if ($this->status_periksa())
 364:     {
 365:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 366:       $this->penokenan();
 367:       /* satu baris data */
 368:       return $this->pddikti["proxy"]->GetRecord($_SESSION["token"], $tabel, $filter);
 369:     }
 370:   }
 371: 
 372:   /**
 373:    * mendapatkan n baris data dari webservice PDDIKTI (equal: select * from [table] where [filter] limit [offset], [limit]). 
 374:    * <br/> catatan: jika tidak muncul, tambahkan alias pada field di filter, misal: p.field atau gunakan nama_tabel.raw
 375:    * @param type $tabel
 376:    * - tabel (PDDIKTI) di mana data disimpan
 377:    * @param type $filter
 378:    * - filter data yang akan diambil - OPSIONAL, default: ""
 379:    * @param type $order
 380:    * - pengurutan data - OPSIONAL, default: ""
 381:    * @param type $batas
 382:    * - banyaknya data yang akan ditampilkan - OPSIONAL, default: 1000000
 383:    * @param type $mulai
 384:    * - dari nomor berapa data akan diambil - OPSIONAL, default: 0
 385:    * @return type
 386:    * - data
 387:    */
 388:   function GetRecordset($tabel, $filter="", $order="", $batas=1000000, $mulai=0)
 389:   {
 390:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 391:     if ($this->status_periksa())
 392:     {
 393:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 394:       $this->penokenan();
 395:       /* data */
 396:       return $this->pddikti["proxy"]->GetRecordset($_SESSION["token"], $tabel, $filter, $order, $batas, $mulai);
 397:     }
 398:   }
 399: 
 400:   /**
 401:    * mendapatkan informasi berapa baris data pada tabel dari webservice PDDIKTI (equal: select sum(1) as jumlah from [table])
 402:    * @param type $tabel
 403:    * - tabel (PDDIKTI) di mana data disimpan
 404:    * @return type
 405:    * - jumlah baris data
 406:    */
 407:   function GetCountRecordset($tabel)
 408:   {
 409:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 410:     if ($this->status_periksa())
 411:     {
 412:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 413:       $this->penokenan();
 414:       /*jumlah baris data */
 415:       return $this->pddikti["proxy"]->GetCountRecordset($_SESSION["token"], $tabel);
 416:     }
 417:   }
 418: 
 419:   /**
 420:    * mendapatkan data yang telah dihapus pada suatu tabel dari webservice PDDIKTI (equal: select * from [table] where [filter] order by [order] limit [offset], [limit])
 421:    * @param type $tabel
 422:    * - tabel (PDDIKTI) di mana data disimpan
 423:    * @param type $filter
 424:    * - filter data yang akan diambil - OPSIONAL, default: ""
 425:    * @param type $order
 426:    * - pengurutan data - OPSIONAL, default: ""
 427:    * @param type $batas
 428:    * - banyaknya data yang akan ditampilkan - OPSIONAL, default: 1000000
 429:    * @param type $mulai
 430:    * - dari nomor berapa data akan diambil - OPSIONAL, default: 0
 431:    * @return type
 432:    * - data
 433:    */
 434:   function GetDeletedRecordset($tabel, $filter, $order, $batas=1000000, $mulai=0)
 435:   {
 436:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 437:     if ($this->status_periksa())
 438:     {
 439:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 440:       $this->penokenan();
 441:       /* data */
 442:       return $this->pddikti["proxy"]->GetDeletedRecordset($_SESSION["token"], $tabel, $filter, $order, $batas, $mulai);
 443:     }
 444:   }
 445: 
 446:   /**
 447:    * mendapatkan informasi berapa baris data yang telah dihapus pada tabel dari webservice PDDIKTI (equal: equal: select sum(1) as jumlah from [table])
 448:    * @param type $tabel
 449:    * - tabel (PDDIKTI) di mana data disimpan
 450:    * @return type
 451:    * - jumlah baris data
 452:    */
 453:   function GetCountDeletedRecordset($tabel)
 454:   {
 455:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 456:     if ($this->status_periksa())
 457:     {
 458:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 459:       $this->penokenan();
 460:       /* jumlah baris data */
 461:       return $this->pddikti["proxy"]->GetCountDeletedRecordset($_SESSION["token"], $tabel);
 462:     }
 463:   }
 464: 
 465:   /**
 466:    * menyisipkan satu baris data ke dalam tabel dari webservice PDDIKTI (equal: insert into [table] (<namakolom>) values (<data>))
 467:    * @param type $tabel
 468:    * - tabel (PDDIKTI) di mana data disimpan
 469:    * @param type $data
 470:    * - data berupa array 1 dimensi yang indeksnya adalah nama kolom dan isinya adalah data. $sisip = array( "namakolom1" => "data1", ... )
 471:    * @return type
 472:    * - status penyisipan data
 473:    */
 474:   function InsertRecord($tabel, $data)
 475:   {
 476:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 477:     if ($this->status_periksa())
 478:     {
 479:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 480:       $this->penokenan();
 481:       /* sisip data */
 482:       return $this->pddikti["proxy"]->InsertRecord($_SESSION["token"], $tabel, json_encode($data, JSON_FORCE_OBJECT));
 483:     }
 484:   }
 485: 
 486:   /**
 487:    * menyisipkan n baris data ke dalam tabel dari webservice PDDIKTI (equal: insert into [table] (<namakolom>) values (<data1>), (<data2>), ...)
 488:    * @param type $tabel
 489:    * - tabel (PDDIKTI) di mana data disimpan
 490:    * @param type $data
 491:    * - data berupa array 2 dimensi yang indeksnya adalah nama kolom dan isinya adalah data. $sisip = array ( array( "namakolom1" => "data1.1", ... ), ... )
 492:    * @return type
 493:    * - status penyisipan data
 494:    */
 495:   function InsertRecordset($tabel, $data)
 496:   {
 497:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 498:     if ($this->status_periksa())
 499:     {
 500:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 501:       $this->penokenan();
 502:       /* sisip data */
 503:       return $this->pddikti["proxy"]->InsertRecordset($_SESSION["token"], $tabel, json_encode($data, JSON_FORCE_OBJECT));
 504:     }
 505:   }
 506: 
 507:   /**
 508:    * mengubah satu baris data di dalam tabel dari webservice PDDIKTI (equal: update [table] set <namakolomdata:data> where <namakolomfilter:datafilter>)
 509:    * @param type $tabel
 510:    * - tabel (PDDIKTI) di mana data disimpan
 511:    * @param type $data
 512:    * - data harus berupa array 2 dimensi dengan indeks bernama 'key' dan 'data', yang masing-masing berupa array yang indeksnya adalah nama kolom dan isinya adalah data.
 513:    *   $ubah = array( "key" => array( "namakolomfilter1" => "datafilter1", ... ), "data" => array( "namakolomdata1" => "data1", ... ) )
 514:    * @return type
 515:    * - status ubah data
 516:    */
 517:   function UpdateRecord($tabel, $data)
 518:   {
 519:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 520:     if ($this->status_periksa())
 521:     {
 522:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 523:       $this->penokenan();
 524:       /* ubah data */
 525:       return $this->pddikti["proxy"]->UpdateRecord($_SESSION["token"], $tabel, json_encode($data, JSON_FORCE_OBJECT));
 526:     }
 527:   }
 528: 
 529:   /**
 530:    * mengubah n baris data di dalam tabel dari webservice PDDIKTI (equal: update [table] set <namakolomdata1:data1>, <namakolomdata2:data2>, ... where <namakolomfilter:datafilter>)
 531:    * @param type $tabel
 532:    * - tabel (PDDIKTI) di mana data disimpan
 533:    * @param type $data
 534:    * - data harus berupa array 3 dimensi dengan sebuah array berupa kumpulan array dengan indeks bernama 'key' dan 'data', yang masing-masing berupa array yang indeksnya adalah nama field dan isinya adalah data.
 535:    *   $ubah = array( "key" => array( "namakolomfilter1" => "datafilter1", ... ), "data" => array( "namakolomdata1.1" => "data1.1", ... ), ... )
 536:    * @return type
 537:    * - status ubah data
 538:    */
 539:   function UpdateRecordset($tabel, $data)
 540:   {
 541:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 542:     if ($this->status_periksa())
 543:     {
 544:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 545:       $this->penokenan();
 546:       /* ubah data */
 547:       return $this->pddikti["proxy"]->UpdateRecordset($_SESSION["token"], $tabel, json_encode($data, JSON_FORCE_OBJECT));
 548:     }
 549:   }
 550: 
 551:   /**
 552:    * menghapus satu baris data secara halus (memberi tanda) di dalam tabel dari webservice PDDIKTI (equal: update <tabel> set soft_delete=1 where <namakolomfilter:datafilter>)
 553:    * @param type $tabel
 554:    * - tabel (PDDIKTI) di mana data disimpan
 555:    * @param type $filter
 556:    * - filter berupa array yang indeksnya adalah nama field dan isinya adalah data.
 557:    *   $hapus = array( "namakolomfilter1" => "datafilter1", ... )
 558:    * @return type
 559:    * - status hapus data
 560:    */
 561:   function DeleteRecord($tabel, $filter)
 562:   {
 563:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 564:     if ($this->status_periksa())
 565:     {
 566:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 567:       $this->penokenan();
 568:       /* hapus data */
 569:       return $this->pddikti["proxy"]->DeleteRecord($_SESSION["token"], $tabel, json_encode($filter, JSON_FORCE_OBJECT));
 570:     }
 571:   }
 572: 
 573:   /**
 574:    * menghapus n baris data secara halus (memberi tanda) di dalam tabel dari webservice PDDIKTI (equal: update <tabel> set soft_delete=1 where <namakolomfilter1:datafilter1>; update <tabel> set soft_delete=1 where <namakolomfilter2:datafilter2>;... )
 575:    * @param type $tabel
 576:    * - tabel (PDDIKTI) di mana data disimpan
 577:    * @param type $filter
 578:    * - filter berupa array yang indeksnya adalah nama field dan isinya adalah data.
 579:    *   $hapus = array ( array( "namakolomfilter1" => "datafilter1", ... ), ... )
 580:    * @return type
 581:    * - status hapus data
 582:    */
 583:   function DeleteRecordset($tabel, $filter)
 584:   {
 585:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 586:     if ($this->status_periksa())
 587:     {
 588:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 589:       $this->penokenan();
 590:       /* hapus data */
 591:       return $this->pddikti["proxy"]->DeleteRecordset($_SESSION["token"], $tabel, json_encode($filter, JSON_FORCE_OBJECT));
 592:     }
 593:   }
 594: 
 595:   /**
 596:    * mengembalikan satu baris data yang telah dihapus secara halus (memberi tanda) di dalam tabel dari webservice PDDIKTI (equal: update <tabel> set soft_delete=0 where <namakolomfilter:datafilter>)
 597:    * @param type $tabel
 598:    * - tabel (PDDIKTI) di mana data disimpan
 599:    * @param type $filter
 600:    * - filter berupa array yang indeksnya adalah nama field dan isinya adalah data.
 601:    *   $hapus = array( "namakolomfilter1" => "datafilter1", ... )
 602:    * @return type
 603:    * - status mengembalikan data
 604:    */
 605:   function RestoreRecord($tabel, $filter)
 606:   {
 607:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 608:     if ($this->status_periksa())
 609:     {
 610:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 611:       $this->penokenan();
 612:       /* mengembalikan data */
 613:       return $this->pddikti["proxy"]->RestoreRecord($_SESSION["token"], $tabel, json_encode($filter, JSON_FORCE_OBJECT));
 614:     }
 615:   }
 616: 
 617:   /**
 618:    * mengembalikan n baris data yang telah dihapus secara halus (memberi tanda) di dalam tabel dari webservice PDDIKTI (equal: update <tabel> set soft_delete=1 where <namakolomfilter1:datafilter1>; update <tabel> set soft_delete=1 where <namakolomfilter2:datafilter2>;... )
 619:    * @param type $tabel
 620:    * - tabel (PDDIKTI) di mana data disimpan
 621:    * @param type $filter
 622:    * - filter berupa array yang indeksnya adalah nama field dan isinya adalah data.
 623:    *   $hapus = array ( array( "namakolomfilter1" => "datafilter1", ... ), ... )
 624:    * @return type
 625:    * - status mengembalikan data
 626:    */
 627:   function RestoreRecordset($tabel, $filter)
 628:   {
 629:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 630:     if ($this->status_periksa())
 631:     {
 632:       /* menjamin keberadaan token, meminta token kembali apabila sudah expire */
 633:       $this->penokenan();
 634:       /* mengembalikan data */
 635:       return $this->pddikti["proxy"]->RestoreRecordset($_SESSION["token"], $tabel, json_encode($filter, JSON_FORCE_OBJECT));
 636:     }
 637:   }
 638: 
 639:   /**
 640:    * mendapatkan versi dari webservice PDDIKTI (dan pesan error, jika ada)
 641:    * @return type
 642:    * - mengembalikan array berisi data versi, disertai dengan informasi error apabila ada masalah dengan koneksi webservice
 643:    */
 644:   function GetVersion()
 645:   {
 646:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 647:     if ($this->status_periksa()) 
 648:     {
 649:         return $this->pddikti["proxy"]->GetVersion($_SESSION["token"]);
 650:     }
 651:   }
 652: 
 653:   /**
 654:    * mendapatkan waktu kadaluarsa dari webservice PDDIKTI
 655:    * @return type
 656:    * - mendapatkan status expired
 657:    */
 658:   function GetExpired()
 659:   {
 660:     /* jika koneksi FEEDER DIKTI tidak bermasalah */
 661:     if ($this->status_periksa())
 662:     {
 663:         return $this->pddikti["proxy"]->GetExpired($_SESSION["token"]);
 664:     }
 665:   }
 666: /*^^ WEBSERVICE PDDIKTI ^^*/
 667: 
 668: /*vv manipulasi DB - WEBSERVICE PDDIKTI vv*/
 669: 
 670:   /**
 671:    * koneksi basis data institusi
 672:    * @return type
 673:    * - id koneksi
 674:    */
 675:   function mysqli_terhubung()
 676:   {
 677:     /* membuat angka random sebagai id koneksi */
 678:     $iddb = rand();
 679:     /* membuat dan menyimpan koneksi */
 680:     $this->db["conn"][$iddb] = new mysqli($this->institusi["db"]["host"], $this->institusi["db"]["username"], $this->institusi["db"]["password"], $this->institusi["db"]["database"]);
 681:     if ($this->db["conn"][$iddb]->connect_error) 
 682:     {
 683:         die("Koneksi ke basis data Institusi gagal: ".$this->db["conn"][$iddb]->connect_error);
 684:     }
 685:     return $iddb;
 686:   }
 687: 
 688:   /**
 689:    * memutus koneksi basis data institusi
 690:    * @param type $iddb
 691:    * - id koneksi
 692:    */
 693:   function mysqli_putus($iddb)
 694:   {
 695:     $this->db["conn"][$iddb]->close();
 696:   }
 697: 
 698:   /**
 699:    * membersihkan hasil
 700:    * @param type $iddb
 701:    * - id koneksi
 702:    */
 703:   function mysqli_bersihkan($iddb)
 704:   {
 705:     if (array_key_exists("result", $this->db))
 706:     {
 707:       if (array_key_exists($iddb, $this->db["result"]))
 708:       {
 709:         if (is_object($this->db["result"][$iddb]))
 710:         {
 711:           $this->db["result"][$iddb]->free();
 712:           $this->db["result"][$iddb]->close();
 713:           unset($this->db["result"][$iddb]);
 714:         }
 715:       }
 716:     }
 717:     if (array_key_exists("field", $this->db))
 718:     {
 719:         unset($this->db["field"][$iddb]);
 720:     }
 721:   }
 722: 
 723:   /**
 724:    * mendapatkan data dari basis data
 725:    * @param type $iddb
 726:    * - id koneksi
 727:    * @param string $sql
 728:    * - berisi statemen yang mengandung query: select <kolom> from <tabel>
 729:    * @param type $filter
 730:    * - filter berupa array dengan indeks: where, order by, limit - OPSIONAL, default=array()
 731:    */
 732:   function mysqli_select($iddb, $sql, $filter=array())
 733:   {
 734:     $this->db["field"][$iddb] = array();
 735:     /* menggabungkan sql dengan filter (jika ada) */
 736:     $sql  .= ((!array_key_exists("where", $filter)) ? "" : ((trim($filter["where"]) == "") ? "" : " where ".$filter["where"])).((!array_key_exists("order by", $filter)) ? "" : ((trim($filter["order by"]) == "") ? "" : " order by ".$filter["order by"])).((!array_key_exists("limit", $filter)) ? "" : ((trim($filter["limit"]) == "") ? "" : " limit ".$filter["limit"]));
 737:     /* eksekusi sql */
 738:     $this->db["result"][$iddb] = $this->db["conn"][$iddb]->query($sql);
 739:     echo $sql;
 740:     /* jika ada data, maka simpan semua nama kolom */
 741:     if ($this->db["result"][$iddb]->num_rows>0) 
 742:     {
 743:       $finfo  = $this->db["result"][$iddb]->fetch_fields();
 744:       foreach ($finfo as $val)
 745:       {
 746:         $this->db["field"][$iddb][]  = $val->name;
 747:       }
 748:     }
 749:     /* simpan pesan kesalahan */
 750:     $this->db["error"][$iddb]  = $this->db["conn"][$iddb]->error;
 751:     /* tampilkan pesan debug apabila dalam mode debug */
 752:     if ($this->debug) 
 753:     {
 754:         echo $sql."<br />";
 755:     }
 756:   }
 757:   
 758:   /**
 759:    * eksekusi insert, update, delete
 760:    * @param type $iddb
 761:    * -id koneksi
 762:    * @param string $sql
 763:    * - berisi statemen yang mengandung query insert, update atau delete
 764:    */
 765:   function mysqli_iud($iddb, $sql)
 766:   {
 767:     /* eksekusi sql */
 768:     $this->db["conn"][$iddb]->query($sql);
 769:     /* simpan pesan kesalahan */
 770:     $this->db["error"][$iddb]  = $this->db["conn"][$iddb]->error;
 771:   }
 772: 
 773:   /**
 774:    * mendapatkan data dari map sesuai dengan tabel yang diinginkan
 775:    * @param type $iddb
 776:    * - id koneksi
 777:    * @param string $tabel
 778:    * - tabel (PDDIKTI) di mana data disimpan
 779:    * @param type $filter
 780:    * - filter berupa array dengan indeks: where, order by, limit - OPSIONAL, default=array()
 781:    * @param type $iscek
 782:    * - apakah hanya cek saja? - OPSIONAL, default=false
 783:    * @param type $iscetak
 784:    * - apakah perlu dicetak? - OPSIONAL, default=false
 785:    */
 786:   function mysqli_mapdb_select($iddb, $tabel, $filter=array(), $iscek=false, $iscetak=false)
 787:   {
 788:     /* eksekusi jika sudah terpetakan di mapdb */
 789:     if (! empty($this->mapdb["table"][$tabel]["nama"]))
 790:     {
 791:       /* buat query dari informasi yang ada di mapdb */
 792:       $sql  = "select ".implode(",", array_filter($this->mapdb["field"][$tabel]))." from ".$this->mapdb["table"][$tabel]["nama"].(($iscek) ? " where null" : "");
 793:       /* eksekusi sql */
 794:       $this->mysqli_select($iddb, $sql, $filter);
 795:     }
 796:     /* apakah perlu dicetak? */
 797:     if ($iscetak)
 798:     {
 799:       $kolom  = $this->infokolominstitusi_mapdb($tabel);
 800:       while($row = $this->db["result"][$iddb]->fetch_assoc())
 801:       {
 802:         for ($i=0; $i<$kolom["count"]; $i++)
 803:         {
 804:           echo $kolom["value"][$i].": ".$row[$kolom["value"][$i]];
 805:         }
 806:         echo "<br />";
 807:       }
 808:       /* bersih-bersih */
 809:       unset($kolom);
 810:     }
 811:   }
 812: 
 813:   /**
 814:    * mendapatkan informasi kolom institusi yang terpetakan ke tabel PDDIKTI
 815:    * @param type $tabel
 816:    * - nama tabel PDDIKTI
 817:    * @return type
 818:    * - info berupa (1) pemetaan lengkap, PDDIKTI sebagai indeks dan institusi sebagai data, (2) jumlah kolom yang dipetakan, dan (3) pemetaan kolom institusi saja (indeks menggunakan angka, mulai dari 0)
 819:    */
 820:   function infokolominstitusi_mapdb($tabel)
 821:   {
 822:     /* masukkan pemetaan lengkap, PDDIKTI sebagai indeks dan institusi sebagai data  */
 823:     $kolom["map"]       = $this->mapdb["field"][$tabel];
 824:     /* jumlah kolom yang dipetakan */
 825:     $kolom["count"]     = count($kolom["map"]);
 826:     /* pemetaan kolom institusi saja (indeks menggunakan angka, mulai dari 0) */
 827:     foreach($kolom["map"] as $kolom["ws"] => $kolom["institusi"])
 828:     {
 829:       $kolom["value"][] = $kolom["institusi"];
 830:     }
 831:     return $kolom;
 832:   }
 833: /*^^ manipulasi DB - WEBSERVICE PDDIKTI ^^*/
 834: 
 835: /*vv sync DB - WEBSERVICE PDDIKTI vv*/
 836: 
 837:   /**
 838:    * memeriksa kecocokan tabel dan isi dari tabel-tabel pada basis data Institusi dengan PDDIKTI
 839:    * @param type $exception
 840:    * - daftar tabel PDDIKTI yang tidak ikut dicocokkan
 841:    */
 842:   function cek_tabel($exception=array())
 843:   {
 844:     /* mendapatkan daftar tabel PDDIKTI */
 845:     $listtable  = $this->ListTable();
 846:     echo "<hr><h1>Check Mapping</h1>";
 847:     echo "<ol><li>Tabel Referensi akan dilihat datanya, selain itu hanya melihat <em>mapping</em> saja</li><li>Apabila ada ketidak-sesuaian antara isi tabel Institusi dan tabel FEEDER PDDIKTI, maka yang harus disesuaikan adalah isi tabel Institusi</li><li>Info selengkapnya dapat dibaca di: <a href='http://bpti.say.ac.id/check-mapping-pada-injector-feeder-dikti-perlukah/'>Check Mapping pada Injector FEEDER DIKTI, Perlukah?</a></li></ol>";
 848:     /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
 849:     $this->kirim_buffer();
 850:     $iddb = $this->mysqli_terhubung();
 851:     /* cek setiap tabel */
 852:     foreach ($listtable["result"] as $tabel)
 853:     {
 854:       /* reset kolom yang sudah dipakai oleh data institusi ($i) */
 855:       $i  = 0;
 856:       echo "<h2>Tabel ".$tabel["table"]."</h2>";
 857:       /* cek mapping tabel PDDIKTI dengan tabel Institusi, tabel belum dipetakan */
 858:       if (count($this->mapdb["table"][$tabel["table"]]["nama"])==0 || $this->mapdb["table"][$tabel["table"]]["nama"]=="")
 859:       {
 860:         echo "Warning! Tabel ".$tabel["table"]." belum dipetakan";
 861:       }
 862:       /* tabel sudah dipetakan */
 863:       else
 864:       {
 865:         echo "Tabel ".$tabel["table"]." dipetakan ke tabel ".$this->mapdb["table"][$tabel["table"]]["nama"]."<br />";
 866:         /* mendapatkan daftar kolom PDDIKTI dari tabel spesifik */
 867:         $listfield  = $this->GetDictionary($tabel["table"]);
 868:         foreach ($listfield["result"] as $idx_field => $kolom)
 869:         {
 870:           /* cek mapping kolom PDDIKTI dengan kolom Institusi */
 871:           echo (($this->mapdb["table"][$tabel["table"]]["nama"][$idx_field]=="") ? "Warning! Field ".$tabel["table"].".".$idx_field." belum dipetakan" : "Field ".$tabel["table"].".".$idx_field." dipetakan ke field ".$this->mapdb["table"][$tabel["table"]]["nama"].".".$this->mapdb["field"][$tabel["table"]][$idx_field])."<br />";
 872:         }
 873:         /* cek keberadaan tabel Institusi */
 874:         $this->mysqli_mapdb_select($iddb, $tabel["table"], array(), true);
 875:         echo (($this->db["error"][$iddb]=="") ? "Tabel ".$tabel["table"]." pada Institusi OK" : $this->db["error"][$iddb])."<br />";
 876:         /* bersih-bersih */
 877:         $this->mysqli_bersihkan($iddb);
 878:         unset($listfield);
 879:       }
 880:       /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
 881:       $this->kirim_buffer();
 882:       /* jika tabel merupakan tabel referensi, maka isinya harus sesuai antara PDDIKTI dengan Institusi */
 883:       if (strtolower($tabel["jenis"])=="ref")
 884:       {      
 885:         /* jika tabel sudah dipetakan, dapatkan data dari institusi */
 886:         if (!(count($this->mapdb["table"][$tabel["table"]]["nama"])==0 || $this->mapdb["table"][$tabel["table"]]["nama"]==""))
 887:         {
 888:           /* dapatkan data dari institusi */
 889:           $this->mysqli_mapdb_select($iddb, $tabel["table"], array("order by" => $this->mapdb["pk"][$tabel["table"]][1], "where" => $this->mapdb["table"][$tabel["table"]]["filter"]));
 890:           $kolom        = $this->infokolominstitusi_mapdb($tabel["table"]);
 891: 
 892:           /* header */
 893:           foreach ($kolom["value"] as $idx => $value)
 894:           {
 895:             $tabel_ref["header"][]  = "ins ".$value;
 896:           }
 897:           /* data institusi, 
 898:            * data akan disimpan berdasarkan nilai kunci primernya, 
 899:            * sehingga akan terlihat apakah dengan primary key yang sama antara data Institusi dan PDDIKTI, memiliki data yang sama
 900:            */
 901:           while($row = $this->db["result"][$iddb]->fetch_assoc())
 902:           {
 903:             /* ambil data hanya yang sudah dipetakan saja */
 904:             for ($i=0; $i<$kolom["count"]; $i++)
 905:             {
 906:               /* jika kolom adalah kolom primary key */
 907:               if ($kolom["value"][$i] == $this->mapdb["pk"][$tabel["table"]][1]) 
 908:               {
 909:                 /* gunakan nilai dari PK sebagai indeks */
 910:                 $indeks = trim($row[$this->ignore_alias($kolom["value"][$i])]);
 911:                 /* tangkap data */
 912:                 $tabel_ref["data"][$indeks][$i] = $row[$this->ignore_alias($kolom["value"][$i])];
 913:               }
 914:               /* kolom selain PK */
 915:               else
 916:               {
 917:                 /* tangkap data, jika terdapat data dobel, maka digabungkan */
 918:                 $tabel_ref["data"][$indeks][$i] .= $row[$this->ignore_alias($kolom["value"][$i])]."; ";
 919:               }
 920:             }
 921:           }
 922:           /* bersih-bersih */
 923:           $this->mysqli_bersihkan($iddb);
 924:           unset($kolom);
 925:         }
 926:         /* dapatkan data dari PDDIKTI */
 927:         /* kecuali yang terdaftar dalam array exception */
 928:         if (!in_array($tabel["table"], $exception))
 929:         {
 930:           $baris  = $this->GetCountRecordset($tabel["table"]);
 931:           $baris  = $baris["result"];
 932:           /* mendapakan 1 baris saja untuk mendapatkan nama field */
 933:           $hasil = $this->GetRecordset($tabel["table"], "", "", 1, 0);
 934:           /* header */
 935:           foreach ($hasil["result"][0] as $idx => $value)
 936:           {
 937:             $tabel_ref["header"][]  = "pdd ".$idx;
 938:           }
 939:           /* tampilkan pesan debug apabila dalam mode debug */
 940:           if ($this->debug) 
 941:           {
 942:               $this->print_r_rapi($hasil);
 943:           }
 944:           /* data diambil per $pddikti["ws"]["limit"] baris agar tidak kehabisan memory */
 945:           for ($awal=0; $awal < $baris; $awal+=$this->pddikti["ws"]["limit"])
 946:           {
 947:             /* ambil data secara parsial, sesuai dengan limit */
 948:             $hasil = $this->GetRecordset($tabel["table"], "", "", $this->pddikti["ws"]["limit"], $awal);
 949:             foreach ($hasil["result"] as $kolom => $row)
 950:             {
 951:               /* kolom dari data PDDIKTI ($j) dimulai dari sebelah kolom yang sudah dipakai oleh data institusi ($i) */
 952:               $j  = $i;
 953:               /* data */
 954:               foreach ($row as $idx => $value)
 955:               {
 956:                 /* gunakan nilai dari PK sebagai indeks */
 957:                 if ($idx == $this->mapdb["pk"][$tabel["table"]][0])
 958:                 {
 959:                     $indeks = trim($value);
 960:                 }
 961:                 /* tangkap data */
 962:                 $tabel_ref["data"][$indeks][$j]  = $value;
 963:                 $j++;
 964:               }
 965:             }
 966:           }
 967:         }
 968:         /* cetak data institusi dan PDDIKTI */
 969:         $this->cetak_tabel($tabel_ref["header"], $tabel_ref["data"]);
 970:         /* bersih-bersih */
 971:         unset($hasil);
 972:         unset($tabel_ref);
 973:       }
 974:     }
 975:     /* bersih-bersih */
 976:     unset($listtable);
 977:     $this->mysqli_putus($iddb);
 978:   }
 979:   
 980:   /**
 981:    * mencetak n baris data dari webservice PDDIKTI
 982:    * @param type $tabel
 983:    * - tabel (PDDIKTI) di mana data disimpan
 984:    * @param type $filter
 985:    * - filter data yang akan diambil - OPSIONAL, default: ""
 986:    * @param type $order
 987:    * - pengurutan data - OPSIONAL, default: ""
 988:    * @param type $batas
 989:    * - banyaknya data yang akan ditampilkan - OPSIONAL, default: 1000000
 990:    * @param type $mulai
 991:    * - dari nomor berapa data akan diambil - OPSIONAL, default: 0
 992:    */
 993:   function cetak_recordset($tabel, $filter="", $order="", $batas=1000000, $mulai=0)
 994:   {
 995:     $row  = array();
 996:     /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
 997:     $this->cetak_tabel_parsial_mulai();
 998:     /* mendapakan 1 baris saja untuk mendapatkan nama field */
 999:     $data = $this->GetRecordset($tabel, "", "", 1, 0);
1000:     /* header */
1001:     foreach ($data["result"][0] as $idx => $value)
1002:     {
1003:       $row[]  = $idx;
1004:     }
1005:     /* mengisi tabel secara terpisah */
1006:     $this->cetak_tabel_parsial($row, true);
1007:     /* data */
1008:     $data = $this->GetRecordset($tabel, $filter, $order, $batas, $mulai);
1009:     /* mengisi tabel secara terpisah */
1010:     $this->cetak_tabel_parsial($data["result"]);
1011:     /* mengakhiri membuat tabel secara terpisah */
1012:     $this->cetak_tabel_parsial_akhiri();
1013:     /* bersih-bersih */
1014:     unset($row);
1015:     unset($data);
1016:   }
1017: 
1018:   /**
1019:    * mensinkronkan GUID pada tabel-tabel basis data Institusi dari basis data Feeder PDDIKTI, 
1020:    * <br/> yaitu mencari baris yang GUID-nya masih kosong (null) pada tabel Institusi kemudian diisi GUID dari PDDIKTI pada tabel yang bersesuaian
1021:    * @param type $tabel
1022:    * - tabel (PDDIKTI) di mana data disimpan
1023:    * @param type $filter
1024:    * - filter data yang akan diambil (PDDIKTI) - OPSIONAL, default: ""
1025:    * @param type $filterIns
1026:    * - filter data yang akan diambil (Institusi) - OPSIONAL, default: ""
1027:    */
1028:   function pddikti_sinkron_guid($tabel, $filter="", $filterIns = "")
1029:   {
1030:     /* ambil nama tabel, karena nama tabel bisa lebih dari satu kata, di mana kata pertama adalah nama tabel, sedangkan kata berikutnya adalah keterangan */
1031:     $tabel_asli = split(" ", $tabel);
1032:     $tabel_asli = $tabel_asli[0];
1033:     echo "<hr /><h2>Sync ".$tabel.((!array_key_exists("filter", $this->mapdb["guid"][$tabel])) ? "" : ", Filter: ".$this->mapdb["guid"][$tabel]["filter"]).(($filterIns == "") ? "" : " and ".$filterIns)."</h2>";
1034:     /* cek, apakah kolom yang harus ada digunakan pada filter? jika tidak, maka proses dihentikan */
1035:     if ($this->mapdb["guid"][$tabel]["prerequisite"] != "" && $this->is_exist($filter, $this->mapdb["guid"][$tabel]["prerequisite"], true) == false)
1036:     {
1037:       echo "Proses sinkronisasi dihentikan karena kebutuhan filter ".$this->mapdb["guid"][$tabel]["prerequisite"]." tidak disediakan. Hal ini untuk menjamin kebenaran data. Mohon hubungi Administrator atau Programmer.";
1038:     }
1039:     /* lolos cek kebutuhan minimal */
1040:     else
1041:     {
1042:       /* cari yang guidnya kosong diinstitusi */
1043:       $iddb = $this->mysqli_terhubung();
1044:       $this->mysqli_select($iddb, "select ".$this->mapdb["pk"][$tabel][1].",".$this->mapdb["guid"][$tabel]["variable"][1].((!array_key_exists("infotambahanerror", $this->mapdb["guid"][$tabel])) ? "" : (($this->mapdb["guid"][$tabel]["infotambahanerror"] != "") ? ",".$this->mapdb["guid"][$tabel]["infotambahanerror"] : ""))." from ".$this->mapdb["guid"][$tabel]["table"]["check"], array("where" => "(".$this->mapdb["guid"][$tabel]["guid"][1]."=\"\" or isnull(".$this->mapdb["guid"][$tabel]["guid"][1]."))".((!array_key_exists("filter", $this->mapdb["guid"][$tabel])) ? "" : (($this->mapdb["guid"][$tabel]["filter"] != "") ? " and ".$this->mapdb["guid"][$tabel]["filter"] : "")).(($filterIns == "") ? "" : " and ".$filterIns), "order by" => $this->mapdb["guid"][$tabel]["order by"]));
1045:       /* tidak ada data */
1046:       if ($this->db["result"][$iddb]->num_rows == 0)
1047:       {
1048:           echo "<br />Tidak ada data yang akan diproses<br />"; 
1049:       }
1050:       /* ada data */
1051:       else 
1052:       {
1053:           echo "<br />Terdapat ".$this->db["result"][$iddb]->num_rows." data yang akan diproses<br />";
1054:       }
1055:       /* proses sinkronisasi jika terdapat GUID yang masih kosong (null) */
1056:       if ($this->db["result"][$iddb]->num_rows > 0)
1057:       {
1058:         $proses = 0;
1059:         $error  = 0;
1060:         /* ambil variabel dari mapdb */
1061:         $v0     = explode(",", $this->mapdb["guid"][$tabel]["variable"][0]); //variabel pddikti
1062:         $v1     = explode(",", $this->mapdb["guid"][$tabel]["variable"][1]); //variabel institusi
1063:         /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
1064:         $this->cetak_tabel_parsial_mulai();
1065:         /* cetak headaer */
1066:         $this->cetak_tabel_parsial(array_merge($this->db["field"][$iddb], array("no sync"), array("keterangan")), true);
1067:         /* data institusi yang GUID masih kosong (null) */
1068:         while($row = $this->db["result"][$iddb]->fetch_row())
1069:         {
1070:           $proses++;
1071:           /* catat no urut proses */
1072:           $row["syn"] = $proses;
1073:           /* cari info guid di feeder pddikti */
1074:           $v  = array();
1075:           reset($v0);
1076:           /* membuat string parameter, misalnya: trim(npsn)='053033' */
1077:           foreach ($v0 as $idx => $value)
1078:           {
1079:             /* rule nama kolom PDDIKTI:
1080:              * dengan raw.  -> nama kolom akan ditampilkan tanpa alias, contoh: raw.kolom1 akan ditampilkan kolom1
1081:              * tanpa  raw.  -> diberikan fungsi trim pada nama kolom,   contoh: kolom1     akan ditampilkan trim(kolom1)
1082:              * dengan alias -> nama kolom akan ditampilkan apa adanya,  contoh: p.kolom1   akan ditampilkan p.kolom1
1083:              */
1084:             $v[]  = (!(strpos($value, ".")!==false || strpos($value, "raw.")!==false)) ? "trim(".$value.")='".$row[$idx+1]."'" : ((strpos($value, "raw.")!==false)?substr($value, 4):$value)."='".$row[$idx+1]."'";
1085:           }
1086:           /* mendapatkan data di PDDIKTI sesuai dengan parameter di atas */
1087:           $rec = $this->GetRecordset($tabel_asli, (($filter)?$filter." and ":"").implode(" and ", $v));
1088:           /* data pada PDDIKTI kosong, berarti ada data yang ada di Institusi tetapi belum masuk ke PDDIKTI, tingkatkan jumlah kesalahan dan tampilkan pesan kesalahan */
1089:           if (!is_array($rec["result"]))
1090:           {
1091:             $error++;
1092:             $row["ket"] = "filter ".implode(" dan ", $v)." tidak ditemukan di tabel $tabel_asli FEEDER PDDIKTI";
1093:             $this->cetak_tabel_parsial($row);
1094:           }
1095:           /* data yang ditemukan pada PDDIKTI lebih dari satu, 
1096:            * membutuhkan penanganan manual 
1097:            */
1098:           elseif (count($rec["result"]) > 1) 
1099:           {
1100:             /* forcedouble untuk tabel PDDIKTI (mapping.inc.php) ini tidak diisi, tingkatkan jumlah kesalahan dan tampilkan pesan kesalahan (tabel di dalam tabel) */
1101:             if (!is_array($this->mapdb["guid"][$tabel]["forcedouble"]))
1102:             {
1103:               $error++;
1104:               $row["ket"] = "filter ".implode(" dan ", $v)." ditemukan lebih dari satu di tabel $tabel_asli FEEDER PDDIKTI"
1105:                             .$this->cetak_tabel_parsial_mulai(2, 2)
1106:                             .$this->cetak_tabel_parsial($rec["result"], false, 2, 2)
1107:                             .$this->cetak_tabel_parsial_akhiri(2, 2);
1108:             }
1109:             /* forcedouble untuk tabel PDDIKTI (mapping.inc.php) ini tidak diisi, penanganan otomatis */
1110:             else
1111:             {
1112:               /* tampilkan pemberitahuan (tabel di dalam tabel) */
1113:               $row["ket"] = "notice! filter ".implode(" dan ", $v)." ditemukan lebih dari satu di tabel $tabel_asli FEEDER PDDIKTI, tetapi sudah dijadikan satu."
1114:                             .$this->cetak_tabel_parsial_mulai(2, 2)
1115:                             .$this->cetak_tabel_parsial($rec["result"], false, 2, 2)
1116:                             .$this->cetak_tabel_parsial_akhiri(2, 2);
1117:               /* $upd: siapkan 1 data diantara data yang dobel sebagai data baru, sehingga data tidak dobel lagi */
1118:               $upd        = $rec["result"][count($rec["result"]) - 1][$this->mapdb["guid"][$tabel]["forcedouble"]["field"]];
1119:               /* samakan data dobel pada tabel Institusi */
1120:               $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' where ".$this->mapdb["pk"][$tabel][1]."='".$row[0]."'");
1121:               /* iterasi pada data dobel PDDIKTI */
1122:               foreach ($rec["result"] as $idx => $val)
1123:               {
1124:                 /* jika data layak untuk diupdate (lihat $upd di atas) */
1125:                 if ($val[$this->mapdb["guid"][$tabel]["forcedouble"]["field"]] != $upd)
1126:                 {
1127:                   /* menggabungkan data pada kolom yang terdefinisi pada forcedouble (mapping.inc.php) dengan 1 data ($upd) */
1128:                   $dataupdate = array(array("key"=>array($this->mapdb["guid"][$tabel]["forcedouble"]["field"] => $val[$this->mapdb["guid"][$tabel]["forcedouble"]["field"]]), "data"=>array($this->mapdb["guid"][$tabel]["forcedouble"]["field"]=>$upd)));
1129:                   $hasil = $this->UpdateRecordset($this->mapdb["guid"][$tabel]["forcedouble"]["table"], $dataupdate);
1130:                   /* tampilkan pesan kesalahan jika proses penggabungan gagal */
1131:                   if ($hasil["result"]["error_desc"] != "") 
1132:                   {
1133:                       $row["ket"] .= "<br />Error: ".$hasil["result"]["error_desc"];
1134:                   }
1135:                   /* hapus data dobel, sisa dari penggabungan */
1136:                   $datadelete = array(array($this->mapdb["guid"][$tabel]["forcedouble"]["field"] => $val[$this->mapdb["guid"][$tabel]["forcedouble"]["field"]]));
1137:                   $this->DeleteRecordset($this->mapdb["guid"][$tabel]["forcedouble"]["table"], $datadelete);
1138:                   /* bersih-bersih */
1139:                   unset($dataupdate, $datadelete);
1140:                 }
1141:               }  
1142:             }
1143:             $this->cetak_tabel_parsial($row);
1144:           }
1145:           /* ditemukan 1 guid yang cocok, perbaharui guid di tabel Institusi */
1146:           else 
1147:           {
1148:             /* ambil nama kolom di PDDIKTI di mana guid berada */
1149:             $g    = explode(",", $this->mapdb["guid"][$tabel]["guid"][0]);
1150:             /* guid pertama ada isinya */
1151:             if ($rec["result"][0][$g[0]] != "")
1152:             {
1153:               reset($g);
1154:               $upd  = array();
1155:               /* buat guid yang diambil dari PDDIKTI, jika lebih dari satu kolom maka akan digabungkan*/
1156:               foreach ($g as $idx => $val)
1157:               {
1158:                 $upd[]  = "'".$rec["result"][0][$val]."'";
1159:               }
1160:               $upd  = "concat(".implode(",", $upd).")";
1161:               /* eksekusi pembaharuan guid ke tabel Institusi */
1162:               echo "<br />Sync >>".$proses.">> table institusi ".$this->mapdb["guid"][$tabel]["table"]["update"]." dengan data ".$this->mapdb["guid"][$tabel]["guid"][1]."=".$upd." dimana ".$this->mapdb["pk"][$tabel][1]."='".$row[0]."' [OK]";
1163:               $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."=".$upd." where ".$this->mapdb["pk"][$tabel][1]."='".$row[0]."'");
1164:               /* tampilkan pesan kesalahan jika proses pembaharuan gagal */
1165:               if ($this->db["error"][$iddb] != "") 
1166:               {
1167:                 $error++;
1168:                 echo "Error! ".$this->db["error"][$iddb];
1169:               }
1170:             }
1171:             /* guid pertama kosong, tampilkan pesan kesalahan */
1172:             else
1173:             {
1174:               $error++;
1175:               $row["ket"] = "filter ".implode(" dan ", $v)." tidak ditemukan di tabel $tabel_asli FEEDER PDDIKTI";
1176:               $this->cetak_tabel_parsial($row);
1177:             }
1178:             /* kirim data ke browser setiap 50 proses */
1179:             if ($proses % 50 == 0)
1180:             {
1181:               echo "<br />Sync ".$tabel." ($proses dari ".$this->db["result"][$iddb]->num_rows.")...<br />";
1182:               $this->kirim_buffer();
1183:             }
1184:             /* bersih-bersih */
1185:             unset($g);
1186:           }
1187:           /* bersih-bersih */
1188:           unset($rec);
1189:         }
1190:         echo "<br />Sync ".$tabel." ($proses dari ".$this->db["result"][$iddb]->num_rows.")...<br />";
1191:         /* mengakhiri membuat tabel secara terpisah */
1192:         $this->cetak_tabel_parsial_akhiri();
1193:         /* informasikan status sync */
1194:         if ($error == 0)
1195:         {
1196:           echo "$proses proses sync berhasil";
1197:         }
1198:         else
1199:         {
1200:           echo "$error kesalahan ditemukan pada $proses proses sync";
1201:         }
1202:         /* bersih-bersih */
1203:         unset($row);
1204:         unset($v0, $v1, $v);
1205:       }
1206:       /* tidak terdapat GUID yang masih kosong (null) */
1207:       else
1208:       {
1209:         echo "Tidak ada proses sync. Mungkin semua data sudah sinkron";
1210:       }
1211:       /* bersih-bersih */
1212:       $this->mysqli_bersihkan($iddb);
1213:       $this->mysqli_putus($iddb);
1214:     }
1215:   }
1216:   
1217:   /**
1218:    * mendapatkan tahunakademik sebelumnya, misal: 20152 -> 20151, 20161 -> 20152
1219:    * @param type $tahunakademik
1220:    * - tahun akademik
1221:    * @return type
1222:    * - tahun akademik sebelum
1223:    */
1224:   function tahunakademiksebelum($tahunakademik)
1225:   {
1226:       return (($tahunakademik % 2 == 0) ? $tahunakademik-1 : ((floor($tahunakademik/10)-1)*10)+2);
1227:   }
1228:   
1229:   /**
1230:    * lawan dari injek. memasukkan data dari PDDIKTI ke Institusi, metode: insert where not exists
1231:    * @param type $tahunakademikkrs
1232:    * - tahun akademik yang digunakan untuk KRS
1233:    * @param type $tabel
1234:    * - tabel (PDDIKTI) di mana data disimpan
1235:    */
1236:   function pddikti_ekstrak($tahunakademikkrs, $tabel)
1237:   {
1238:     /* jika istahunakademikkrs bernilai false, maka sesuaikan tahunakademikkrs */
1239:     $tahunakademikkrs = (($this->mapdb["extract"][$tabel]["istahunakademikkrs"]) ? $tahunakademikkrs : $this->tahunakademiksebelum($tahunakademikkrs));
1240:     echo "<hr /><h2>EXTRACT Data $tabel $tahunakademikkrs</h2>";
1241:     /* siapkan variabel */
1242:     $n      = $this->GetCountRecordset($tabel, $filter);
1243:     $v0     = explode(",", $this->mapdb["extract"][$tabel]["uniquefield"][0]); //feeder pddikti
1244:     $v1     = explode(",", $this->mapdb["extract"][$tabel]["uniquefield"][1]); //institusi
1245:     $iddb   = $this->mysqli_terhubung();
1246:     $proses = 0;
1247:     /* sesuaikan keyword dengan data, dapatkan data dari feeder pddikti */
1248:     $filter = str_replace("[tahun]", substr($tahunakademikkrs, 0, 4), str_replace("[tahunakademik]", $tahunakademikkrs, $this->mapdb["extract"][$tabel]["filtertahunakademik"]));
1249:     $data   = $this->GetRecordset($tabel, $filter);
1250:     /* ambil semua data dari PDDIKTI */
1251:     foreach ($data["result"] as $row)
1252:     {
1253:       $v  = array();
1254:       reset($v1);
1255:       /* membuat string parameter*/
1256:       foreach ($v0 as $idx => $value)
1257:       {
1258:         $v[]  = $value."='".$row[$v1[$idx]]."'";
1259:       }
1260:       /* menyiapkan data yang akan disisipkan */
1261:       $columnlist   = array();
1262:       $datalist     = array();
1263:       foreach ($this->mapdb["field"][$tabel] as $idx=>$value)
1264:       {
1265:           if ($value != "null")
1266:           {
1267:             $columnlist[] = $value;
1268:             $datalist[]   = "'".$row[$idx]."'";
1269:           }
1270:       }
1271:       /* eksekusi penyisipan data */
1272:       $this->mysqli_iud($iddb, "insert into ".$this->mapdb["extract"][$tabel]["table"]." (".implode(",", $columnlist).") select ".implode(",", $datalist)." from ".$this->mapdb["extract"][$tabel]["table"]." where not exists (select 1 from ".$this->mapdb["extract"][$tabel]["table"]." where ".implode(" and ", $v).") limit 0,1");
1273:       echo "<br /><b>--Extract >>".++$proses.">> </b> insert jika belum ada data pada tabel institusi ".$this->mapdb["extract"][$tabel]["table"]." dengan data ".implode(",", $datalist);
1274:       /* kirim data ke browser setiap 50 proses */
1275:       if ($proses % 50 == 0)
1276:       {
1277:         echo "<br />Extract $tabel ($proses dari ".$n["result"].")...<br />";
1278:         $this->kirim_buffer();
1279:       }
1280:     }
1281:     echo "<br />Extract $tabel ($proses dari ".$n["result"].")...<br />Proses telah selesai!";
1282:     /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
1283:     $this->kirim_buffer();
1284:     /* bersih-bersih */
1285:     unset($row);
1286:     unset($v, $v0, $v1, $columnlist, $datalist);
1287:     $this->mysqli_bersihkan($iddb);
1288:     $this->mysqli_putus($iddb);
1289:   }
1290:   
1291:   /**
1292:    * cek apakah semua dosen mengajar sudah dimasukkan ke Penugasan di Feeder
1293:    * @param type $tahunakademik
1294:    * - tahun akademik
1295:    * @return type
1296:    * - true: semua dosen sudah dimasukkan ke penugasan, false: belum semua dosen sudah dimasukkan ke penugasan
1297:    */
1298:   function cek_penugasan($tahunakademik)
1299:   {
1300:       /* mengupdate data NIDN/NUPN di tabel Institusi */
1301:       $this->update_nidn();
1302:       /* memasukkan data dosen_pt dari PDDIKTI ke Institusi */
1303:       $this->pddikti_ekstrak($tahunakademik, "dosen_pt");
1304:       /* sesuaikan tahunakademik menjadi tahunakademik sebelumnya */
1305:       $tahunakademik    = $this->tahunakademiksebelum($tahunakademik);
1306:       echo "<hr /><h3>Cek Penugasan Untuk Transaksi T.A. $tahunakademik</h3>";
1307:       $iddb = $this->mysqli_terhubung();
1308:       /* dapatkan daftar pengajar yang tidak ada di dalam penugasan pada tahunakademik bersangkutan */
1309:       $que  = "select distinct guiddosen, namalengkap from ((select guiddosen, namalengkap from ak_jadwalkuliah jk join ak_timteaching tt on tt.kdtimteaching=ifnull(jk.kdtimteachingperubahan, jk.kdtimteaching) join ak_penawaranmatakuliah pm on pm.kdpenawaran=tt.kdpenawaran join pt_person p on p.kdperson=tt.kdpersonepsbed where tt.kdtahunakademik=".$tahunakademik." and tt.isignore=0 and pm.isignore=0 and jk.kdtahunakademik=".$tahunakademik." and pm.kdtahunakademik=".$tahunakademik." and isrealisasi=1) union all (select guiddosen, namalengkap from ak_jadwalkuliah_lab jk join ak_timteaching_lab tt on tt.kdtimteaching=ifnull(jk.kdtimteachingperubahan, jk.kdtimteaching) join ak_kelompok kl on kl.kdkelompok=tt.kdkelompok join ak_penawaranmatakuliah pm on pm.kdpenawaran=kl.kdpenawaran join pt_person p on p.kdperson=tt.kdpersonepsbed where tt.kdtahunakademik=".$tahunakademik." and tt.isignore=0 and pm.isignore=0 and jk.kdtahunakademik=".$tahunakademik." and pm.kdtahunakademik=".$tahunakademik." and isrealisasi=1)) cek_dosen where guiddosen not in (select id_sdm from ak_penugasan where tahun=left(".$tahunakademik.", 4))";
1310:       $this->mysqli_select($iddb, $que);
1311:       /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
1312:       $this->cetak_tabel_parsial_mulai();
1313:       /* tampilkan data dosen yang belum dimasukkan di penugasan */
1314:       while ($row = $this->db["result"][$iddb]->fetch_assoc()) 
1315:       {
1316:         $this->cetak_tabel_parsial($row);
1317:       }
1318:       /* apakah semua masuk tabel penugasan institusi? */
1319:       $issemuapenugasan = ($this->db["result"][$iddb]->num_rows == 0);
1320:       /* mengakhiri membuat tabel secara terpisah */
1321:       $this->cetak_tabel_parsial_akhiri();
1322:       /* bersih bersih */
1323:       $this->mysqli_bersihkan($iddb);
1324:       $this->mysqli_putus($iddb);
1325:       return $issemuapenugasan;
1326:   }
1327:   
1328:   /**
1329:    * mengupdate data NIDN/NUPN di tabel Institusi
1330:    */
1331:   function update_nidn()
1332:   {
1333:     echo "<hr /><h2>Update NIDN</h2>";
1334:     $proses = 0;
1335:     $n      = $this->GetCountRecordset($this->mapdb["updatenidn"]["table"][0]);
1336:     /* dapatkan data penugasan di PDDIKTI */
1337:     $data = $this->GetRecordset($this->mapdb["updatenidn"]["table"][0]);
1338:     /* update data penugasan di Institusi */
1339:     $iddb = $this->mysqli_terhubung();
1340:     foreach ($data["result"] as $row)
1341:     {
1342:       /* eksekusi update */
1343:       $this->mysqli_iud($iddb, "update ".$this->mapdb["updatenidn"]["table"][1]." set ".$this->mapdb["updatenidn"]["nidn"][1]."='".$row[$this->ignore_alias($this->mapdb["updatenidn"]["nidn"][0])]."' where ".str_replace(":guid",$row[$this->ignore_alias($this->mapdb["updatenidn"]["guid"])],$this->mapdb["updatenidn"]["filter"]));
1344:       /* kirim data ke browser setiap 50 proses */
1345:       if (++$proses % 50 == 0)
1346:       {
1347:         echo "<br />Update NIDN ($proses dari ".$n["result"].")...<br />";
1348:         $this->kirim_buffer();
1349:       }
1350:       /* bersih-bersih */
1351:       $this->mysqli_bersihkan($iddb);
1352:     }
1353:     echo "<br />Update NIDN ($proses dari ".$n["result"].")...<br />Proses telah selesai!";
1354:     /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
1355:     $this->kirim_buffer();
1356:     /* bersih-bersih */
1357:     unset($data);
1358:     $this->mysqli_putus($iddb);
1359:   }
1360:   
1361:   /**
1362:    * membuat string filter akademik
1363:    * @param type $tahunakademik
1364:    * - kolom tahun akademik (mapping.inc.php)
1365:    * @param type $tandatahunakademik
1366:    * - tanda tahun akademik
1367:    * @param type $istahunakademikkrs
1368:    * - apakah tahun akademik krs
1369:    * @param type $tahunakademikkrs
1370:    * - tahun akademik krs
1371:    * @param type $tahunakademiksebelum
1372:    * - tahun akademik krs sebelumnya
1373:    * @return type
1374:    * - string filter akademik
1375:    */
1376:   function filtertahunakademik($tahunakademik, $tandatahunakademik, $istahunakademikkrs, $tahunakademikkrs, $tahunakademiksebelum)
1377:   {
1378:       /* dapatkan daftar kolom tahun akademik */
1379:       $array_tahunakademik  = split(",", $tahunakademik);
1380:       $array_filter         = array();
1381:       /* jika kolom tahun akademik lebih dari satu */
1382:       if (is_array($array_tahunakademik))
1383:       {
1384:         /* gabungkan kolom tahun akademik dengan tahun akademik untuk semua kolom */
1385:         foreach ($array_tahunakademik as $value_tahunakademik)
1386:         {
1387:             $array_filter[]   = $value_tahunakademik.$tandatahunakademik.(($istahunakademikkrs) ? $tahunakademikkrs : $tahunakademiksebelum);
1388:         }
1389:         return implode(" and ", $array_filter);
1390:       }
1391:       /* jika kolom tahun akademik hanya satu */
1392:       else
1393:       {
1394:           return $tahunakademik.$tandatahunakademik.(($istahunakademikkrs) ? $tahunakademikkrs : $tahunakademiksebelum);
1395:       }
1396:   }
1397: 
1398:   /**
1399:    * memasukkan data dari tabel Institusi ke PDDIKTI
1400:    * @param type $tahunakademikkrs
1401:    * - tahun akademik krs
1402:    * @param type $tabelinjectindividual
1403:    * - nama tabel PDDIKTI, jika diisi, maka hanya tabel ini saja yang diinjek - OPSIONAL, default: ""
1404:    */
1405:   function pddikti_injek($tahunakademikkrs, $tabelinjectindividual="")
1406:   {
1407:     echo "<hr /><h2>INJECT Data $tahunakademikkrs</h2>";
1408:     /* hitung tahun akademik sebelum */
1409:     $tahunakademiksebelum = $this->tahunakademiksebelum($tahunakademikkrs);
1410:     /* cek data penugasan terlebih dahulu, jika belum semua dosen ditugaskan, maka proses injek dibatalkan */
1411:     if(!$this->cek_penugasan($tahunakademikkrs))
1412:     {
1413:         echo "<br /><H2>Belum semua Dosen didaftarkan pada Penugasan, proses INJECT PDDIKTI dibatalkan. Silakan daftarkan semua nama Dosen di atas<br />";
1414:         exit();
1415:     }
1416:     $iddb = $this->mysqli_terhubung();
1417:     foreach ($this->mapdb["inject"] as $tabel => $inject)
1418:     {
1419:       /* eksekusi: 
1420:        * jika tabelinjectindividual tidak kosong maka eksekusi sesuai tabelinjectindividual saja
1421:        * atau jika sebaliknya maka eksekusi yang ignoreinject=false
1422:        */
1423:       if ($tabelinjectindividual!="" && $tabelinjectindividual==$tabel)
1424:       {
1425:         $mode = MODE_INJECT_INDIVIDU;
1426:       }
1427:       else if ($tabelinjectindividual=="" && $inject["ignoreinject"]==false)
1428:       {
1429:         $mode = MODE_INJECT_MASSAL;
1430:       }
1431:       else
1432:       {
1433:         $mode = MODE_INJECT_GAGAL;
1434:       }
1435:       /* jika tidak gagal (setting pada mapping.inc.php benar) */
1436:       if($mode == MODE_INJECT_INDIVIDU || $mode == MODE_INJECT_MASSAL)
1437:       {
1438:         $proses = 0;
1439:         $tabel_asli = split(" ", $tabel);
1440:         $tabel_asli = $tabel_asli[0];
1441:         /* sync guid sebelum inject, siapa tahu sudah masuk sebelumnya 
1442:          * boleh diaktifkan, atau dikomentari, tergantung kebutuhan
1443:          */
1444:         /*
1445:         if ($mode == MODE_INJECT_MASSAL)
1446:         {
1447:           if (array_key_exists("tahunakademik", $inject))
1448:             $this->pddikti_sinkron_guid($tabel, "", $inject["tahunakademik"]."=".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum));
1449:           else
1450:             $this->pddikti_sinkron_guid($tabel);
1451:         }*/
1452:         echo "<hr /><h3>Inject $tabel ".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum)." - Metode ".$inject["type"]."</h3><br />";
1453:         /* siapkan kolom-kolom yang digunakan */
1454:         $param  = array();
1455: /* insert */
1456:         if ($inject["type"]=="insert")
1457:         {
1458:           /* dapatkan kolom untuk didapatkan dari basis data institusi, kecuali PK */
1459:           foreach ($this->mapdb["field"][$tabel] as $pddikti => $institusi)
1460:           {
1461:             if ($pddikti != $this->mapdb["pk"][$tabel][0]) 
1462:             {
1463:                 $param[] = $institusi;
1464:             }
1465:           }
1466:         }
1467: /* update */
1468:         else if ($inject["type"]=="update")
1469:         {
1470:           /* dapatkan kolom untuk didapatkan dari basis data institusi */
1471:           foreach ($inject["fieldwhere"] as $idx => $pddikti)
1472:           {
1473:             $param[] = $this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)];
1474:           }
1475:           foreach ($inject["fieldupdate"] as $idx => $pddikti)
1476:           {
1477:             $param[] = $this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)];
1478:           }
1479:         }
1480:         /* ambil data untuk yang jenisfilternya terisi */
1481:         if (array_key_exists("jenisfilter", $inject))
1482:         {
1483:           /* jenisfilter = internalfilter */
1484:           if ($inject["jenisfilter"] == "internalfilter")
1485:           {
1486:             /* jika tahunakademiknya terisi, ganti string [internalfilter] */
1487:             if (array_key_exists("tahunakademik", $inject))
1488:             {
1489:                 $que  = str_replace("[internalfilter]", $this->filtertahunakademik($inject["tahunakademik"], $inject["tandatahunakademik"], $inject["istahunakademikkrs"], $tahunakademikkrs, $tahunakademiksebelum)." and isnull(".$this->mapdb["field"][$tabel][$this->ignore_alias($this->mapdb["pk"][$tabel][0])].")".((!array_key_exists("filter", $inject)) ? "" : (($inject["filter"] != "") ? " and ".$inject["filter"] : "")), $inject["table"]);
1490:             }
1491:             /* jika tahunakademiknya tidak terisi, ganti string [internalfilter] */
1492:             else
1493:             {
1494:                 $que  = str_replace("[internalfilter]", "isnull(".$this->mapdb["field"][$tabel][$this->ignore_alias($this->mapdb["pk"][$tabel][0])].")".((!array_key_exists("filter", $inject)) ? "" : (($inject["filter"] != "") ? " and ".$inject["filter"] : "")), $inject["table"]);
1495:             }
1496:             /* eksekusi */
1497:             $this->mysqli_select($iddb, $que);
1498:           }
1499:         }
1500:         /* ambil data untuk yang jenisfilternya tidak terisi */
1501:         else
1502:         {
1503:           /* jika tahunakademiknya terisi */
1504:           if (array_key_exists("tahunakademik", $inject))
1505:           {
1506:               $this->mysqli_select($iddb, "select ".$this->mapdb["pk"][$tabel][1].",".implode(",", $param).((!array_key_exists("infotambahanerror", $inject)) ? "" : (($inject["infotambahanerror"] != "") ? ",".$inject["infotambahanerror"] : ""))." from ".$inject["table"], array("where" => $this->filtertahunakademik($inject["tahunakademik"], $inject["tandatahunakademik"], $inject["istahunakademikkrs"], $tahunakademikkrs, $tahunakademiksebelum)." and isnull(".$this->mapdb["field"][$tabel][$this->ignore_alias($this->mapdb["pk"][$tabel][0])].")".((!array_key_exists("filter", $inject)) ? "" : (($inject["filter"] != "") ? " and ".$inject["filter"] : ""))));
1507:           }
1508:           /* jika tahunakademiknya tidak terisi */
1509:           else
1510:           {
1511:               $this->mysqli_select($iddb, "select ".$this->mapdb["pk"][$tabel][1].",".implode(",", $param).((!array_key_exists("infotambahanerror", $inject)) ? "" : (($inject["infotambahanerror"] != "") ? ",".$inject["infotambahanerror"] : ""))." from ".$inject["table"], array("where" => "isnull(".$this->mapdb["field"][$tabel][$this->ignore_alias($this->mapdb["pk"][$tabel][0])].")".((!array_key_exists("filter", $inject)) ? "" : (($inject["filter"] != "") ? " and ".$inject["filter"] : ""))));
1512:           }
1513:         }
1514:         $error  = 0;
1515:         /* tidak ada data dari PDDIKTI yang dapat diproses */
1516:         if ($this->db["result"][$iddb]->num_rows == 0) 
1517:         {
1518:             echo "<br />Tidak ada data yang akan diproses<br />"; 
1519:         }
1520:         /* terdapat data dari PDDIKTI yang dapat diproses */
1521:         else
1522:         {
1523:           echo "<br />Terdapat ".$this->db["result"][$iddb]->num_rows." data yang akan diproses<br />";
1524:           /* memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end) */
1525:           $this->cetak_tabel_parsial_mulai();
1526:           /* cetak headaer */
1527:           $this->cetak_tabel_parsial(array_merge($this->db["field"][$iddb], array("no sync"), array("keterangan")), true);
1528: /*-- insert --*/
1529:           if ($inject["type"]=="insert")
1530:           {
1531:             /* proses data dari Institusi */
1532:             while($row = $this->db["result"][$iddb]->fetch_assoc())
1533:             {
1534:               $proses++;
1535:               /* siapkan data yang hendak dimasukkan ke pddikti */
1536:               $data = array();
1537:               reset($this->mapdb["field"][$tabel]);
1538:               foreach ($this->mapdb["field"][$tabel] as $pddikti => $institusi)
1539:               {
1540:                 /* kunci primer tidak ikut dimasukkan */
1541:                 if ($pddikti != $this->mapdb["pk"][$tabel][0]) 
1542:                 {
1543:                   if ($row[$this->ignore_alias($institusi)] != null)
1544:                   {
1545:                       $data[$pddikti] = $row[$this->ignore_alias($institusi)];
1546:                   }
1547:                 }
1548:               }
1549:               /* injeksi data ke PDDIKTI */
1550:               $hasil = $this->InsertRecord($tabel_asli, $data);
1551:               /* tampilkan kesalahan jika ada */
1552:               if ($hasil["result"]["error_desc"] != "") 
1553:               {
1554:                 $error++;
1555:                 $row["no sync"] = $proses;
1556:                 $row["ket"]     = $hasil["result"]["error_desc"];
1557:                 $this->cetak_tabel_parsial($row);
1558:               }
1559:               /*
1560:                * apabila data berhasil dimasukkan, maka segera update guid yang ada di tabel institusi sesuai dengan guid yang didapatkan dari webservice
1561:                * guid berada pada satu kolom
1562:                */
1563:               else if ($hasil["result"][$this->mapdb["guid"][$tabel_asli]["guid"][0]] != "")
1564:               {
1565:                 echo "<br /><b>Sisip >>".$proses.">> </b>";
1566:                 print_r($data);
1567:                 echo "<b> [OK]</b>";
1568:                 /* sinkronisasi jika modenya adalah injek massal */
1569:                 if ($mode == MODE_INJECT_MASSAL)
1570:                 {
1571:                   $upd  = $hasil["result"][$this->mapdb["guid"][$tabel_asli]["guid"][0]];
1572:                   echo "<br /><b>--Sync Sisip >>".$proses.">> </b> sync tabel institusi ".$this->mapdb["guid"][$tabel]["table"]["update"]." dengan data ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' dimana ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'";
1573:                   $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' where ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'");
1574:                 }
1575:               }
1576:               /* apabila data berhasil dimasukkan, maka segera update guid yang ada di tabel institusi sesuai dengan guid yang didapatkan dari webservice 
1577:                * guid berada pada lebih dari satu kolom atau tidak terdapat kunci primer pada tabel PDDIKTI
1578:                */
1579:               else
1580:               {
1581:                 echo "<br /><b>Sisip >>".$proses.">> </b>";
1582:                 print_r($data);
1583:                 echo "<b> [OK]</b>";
1584:                 /* sinkronisasi jika modenya adalah injek massal */
1585:                 if ($mode == MODE_INJECT_MASSAL)
1586:                 {
1587:                   $g    = explode(",", $this->mapdb["guid"][$tabel]["guid"][0]);
1588:                   reset($g);
1589:                   $upd  = array();
1590:                   foreach ($g as $idx => $val)
1591:                   {
1592:                       $upd[]  = "'".$row[$this->ignore_alias($this->mapdb["field"][$tabel][$this->ignore_alias($val)])]."'";
1593:                   }
1594:                   $upd  = "concat(".implode(",", $upd).")";
1595:                   echo "<br /><b>--Sync Sisip >>".$proses.">> </b> sync tabel institusi ".$this->mapdb["guid"][$tabel]["table"]["update"]." dengan data ".$this->mapdb["guid"][$tabel]["guid"][1]."=".$upd." dimana ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'";
1596:                   $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."=".$upd." where ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'");
1597:                 }
1598:               }
1599:               /* kirim data ke browser setiap 50 proses */
1600:               if ($proses % 50 == 0)
1601:               {
1602:                 echo "<br />Inject $tabel ".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum)." - Metode ".$inject["type"]." ($proses dari ".$this->db["result"][$iddb]->num_rows.")...<br />";
1603:                 $this->kirim_buffer();
1604:               }
1605:               /* bersih-bersih */
1606:               unset($data);
1607:             }
1608:           }
1609: /*-- update -- */
1610:           else if ($inject["type"]=="update")
1611:           {
1612:             /* proses data dari Institusi */
1613:             while($row = $this->db["result"][$iddb]->fetch_assoc())
1614:             {
1615:               $proses++;
1616:               /* siapkan data yang hendak diperbaharui ke pddikti */
1617:               $data   = array();
1618:               /* kolom yang diupdate */
1619:               reset($inject["fieldupdate"]);
1620:               foreach ($inject["fieldupdate"] as $idx => $pddikti)
1621:               {
1622:                   /* data null tidak disertakan */
1623:                   if ($row[$this->ignore_alias($this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)])] != null) 
1624:                   {
1625:                       $data["data"][$pddikti] = $row[$this->ignore_alias($this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)])];
1626:                   }
1627:               }
1628:               /* kolom filter */
1629:               reset($inject["fieldwhere"]);
1630:               foreach ($inject["fieldwhere"] as $idx => $pddikti)
1631:               {
1632:                   /* data null tidak disertakan */
1633:                   if ($row[$this->ignore_alias($this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)])] != null) 
1634:                   {
1635:                       $data["key"][$pddikti]  = $row[$this->ignore_alias($this->mapdb["field"][$tabel][$this->ignore_alias($pddikti)])];
1636:                   }
1637:               }
1638:               /* injeksi data ke PDDIKTI */
1639:               $hasil = $this->UpdateRecord($tabel_asli, $data);
1640:               /* tampilkan kesalahan jika ada */
1641:               if ($hasil["result"]["error_desc"] != "")
1642:               {
1643:                 $error++;
1644:                 $row["no sync"] = $proses;
1645:                 $row["ket"]     = $hasil["result"]["error_desc"];
1646:                 $this->cetak_tabel_parsial($row);
1647:               }
1648:               /* apabila data berhasil dimasukkan, maka segera update guid yang ada di tabel institusi sesuai dengan guid yang didapatkan dari webservice 
1649:                * guid berada pada satu kolom
1650:                */
1651:               else if ($hasil["result"][$this->mapdb["guid"][$tabel_asli]["guid"][0]] != "")
1652:               {
1653:                 echo "<br /><b>Ubah >>".$proses.">> </b>";
1654:                 print_r($data);
1655:                 echo "<b> [OK]</b>";
1656:                 if ($mode == MODE_INJECT_MASSAL)
1657:                 {
1658:                   $upd  = $hasil["result"][$this->mapdb["guid"][$tabel_asli]["guid"][0]];
1659:                   echo "<br /><b>--Sync Ubah >>".$proses.">> </b> sync tabel institusi ".$this->mapdb["guid"][$tabel]["table"]["update"]." dengan data ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' dimana ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'";
1660:                   $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' where ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'");
1661:                 }
1662:               }
1663:               /* apabila data berhasil dimasukkan, maka segera update guid yang ada di tabel institusi sesuai dengan guid yang didapatkan dari webservice 
1664:                * guid berada pada lebih dari satu kolom atau tidak terdapat kunci primer pada tabel PDDIKTI
1665:                */
1666:               else
1667:               {
1668:                 echo "<b><br />Ubah >>".$proses.">> </b>";
1669:                 //tidak terdapat primary key pada tabel PDDIKTI
1670:                 print_r($data);
1671:                 echo "<b> [OK]</b>";
1672:                 if ($mode == MODE_INJECT_MASSAL)
1673:                 {
1674:                   $upd  = implode("", $data["key"]);
1675:                   echo "<br /><b>--Sync Ubah >>".$proses.">> </b> sync tabel institusi ".$this->mapdb["guid"][$tabel]["table"]["update"]." dengan data ".$this->mapdb["guid"][$tabel]["guid"][1]."=".$upd." dimana ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'";
1676:                   $this->mysqli_iud($iddb, "update ".$this->mapdb["guid"][$tabel]["table"]["update"]." set ".$this->mapdb["guid"][$tabel]["guid"][1]."='".$upd."' where ".$this->mapdb["pk"][$tabel][1]."='".$row[$this->ignore_alias($this->mapdb["pk"][$tabel][1])]."'");
1677:                 }
1678:               }
1679:               /* kirim data ke browser setiap 50 proses */
1680:               if ($proses % 50 == 0)
1681:               {
1682:                 echo "<br />Inject $tabel ".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum)." - Metode ".$inject["type"]." ($proses dari ".$this->db["result"][$iddb]->num_rows.")...";
1683:                 $this->kirim_buffer();
1684:               }
1685:               /* bersih-bersih */
1686:               unset($data);
1687:             }
1688:           }
1689:           $this->cetak_tabel_parsial_akhiri();
1690:         }
1691:         /* tampilkan informasi proses */
1692:         echo "<br />Inject $tabel ".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum)." - Metode ".$inject["type"]." ($proses dari ".$this->db["result"][$iddb]->num_rows.")...<br />";
1693:         if ($error == 0)
1694:         {
1695:             echo "$proses proses inject/sync berhasil";
1696:         }
1697:         else
1698:         {
1699:             echo "$error kesalahan ditemukan pada $proses proses sync";
1700:         }
1701:         $this->kirim_buffer();
1702:       }
1703:       /* sinkronisasi guid semua data yang sudah diinjek */
1704:       if ($mode == MODE_INJECT_MASSAL)
1705:       {
1706:         if (array_key_exists("tahunakademik", $inject))
1707:         {
1708:             $this->pddikti_sinkron_guid($tabel, "", $inject["tahunakademik"]."=".(($inject["istahunakademikkrs"]) ? $tahunakademikkrs : $tahunakademiksebelum));
1709:         }
1710:         else
1711:         {
1712:             $this->pddikti_sinkron_guid($tabel);
1713:         }
1714:       }
1715:       unset($inject);
1716:       unset($param);
1717:     }
1718:     /* bersih-bersih */
1719:     $this->mysqli_bersihkan($iddb);
1720:     $this->mysqli_putus($iddb);
1721:   }
1722: 
1723: /*^^ sync DB - WEBSERVICE PDDIKTI ^^*/
1724: 
1725:   /**
1726:    * mengabaikan alias tabel pada nama kolom, misal: p.kdkrsnilai menjadi kdkrsnilai
1727:    * @param type $str
1728:    * - nama kolom (yang mungkin ada alias tabelnya)
1729:    * @return type
1730:    * - nama kolom tanpa alias tabel
1731:    */
1732:   function ignore_alias($str)
1733:   {
1734:     return (strpos($str, '.') === false) ? $str : substr($str, strpos($str, '.')+1);
1735:   }
1736:   
1737:   /**
1738:    * apakah kumpulan kata yang dipisahkan dengan tanda koma ada pada kalimat
1739:    * @param type $haysack
1740:    * - kalimat lengkap
1741:    * @param type $needles
1742:    * - kata dicari
1743:    * @param type $restrict
1744:    * - restrict=true berarti harus semua kata ditemukan
1745:    * @return type
1746:    * - true: terdapat kata, false: tidak terdapat kata
1747:    */
1748:   function is_exist($haysack, $needles, $restrict=false)
1749:   {
1750:     $needle     = split(",", $needles);
1751:     $found      = 0;
1752:     $tobefound  = count($needle);
1753:     foreach ($needle as $n)
1754:     {
1755:         if (strpos($haysack, $n)!==false) 
1756:         {
1757:             $found++;
1758:         }
1759:     }
1760:     return (($restrict && $found == $tobefound && $found > 0) || (!$restrict && $found > 0)) ? true : false;
1761:   }
1762:   
1763:   /**
1764:    * mencetak array dalam bentuk yang mudah untuk dibaca
1765:    * @param type $arr
1766:    * - array yang akan ditampilkan
1767:    */
1768:   function print_r_rapi($arr)
1769:   {
1770:     echo "<pre>";
1771:     print_r($arr);
1772:     echo "</pre>";
1773:     /* mengirimkan buffer terakhir ke browser, kemudian membersihkan buffer */
1774:     $this->kirim_buffer();
1775:   }
1776: 
1777:   /**
1778:    * mencetak tabel dari array header dan data
1779:    * @param type $header
1780:    * - array header
1781:    * @param type $data
1782:    * - array data
1783:    */
1784:   function cetak_tabel($header, $data)
1785:   {
1786:     echo "<table border='1'>";
1787:     /* cetak header */
1788:     echo "<tr>";
1789:     foreach ($header as $idx => $cell)
1790:     {
1791:         echo "<td>$cell</td>";
1792:     }
1793:     echo "</tr>";
1794:     /* cetak data */
1795:     $row  = 0;
1796:     foreach ($data as $idx => $value)
1797:     {
1798:       echo "<tr>";
1799:       for ($i=0; $i<count($header); $i++)
1800:       {
1801:           echo "<td>".$value[$i]."</td>";
1802:       }
1803:       echo "</tr>";
1804:       /* cetak secara parsial */
1805:       if ($row++ % 1000 == 0)
1806:       {
1807:           $this->kirim_buffer();
1808:       }
1809:     }
1810:     echo "</table>";
1811:     echo "Terdapat $row baris<br />";
1812:   }
1813: 
1814:   /**
1815:    * menghitung berapa dimensi array
1816:    * <br/> sumber: http://theserverpages.com/php/manual/en/ref.array.php
1817:    * @param type $array
1818:    * - array yang dihitung dimensinya
1819:    * @return int
1820:    * - dimensi
1821:    */
1822:   function countdim($array)
1823:   {
1824:     if (is_array(reset($array)))
1825:     { 
1826:         $return = $this->countdim(reset($array)) + 1;
1827:     }
1828:     else
1829:     {
1830:         $return = 1;
1831:     }
1832:     return $return;
1833:   }
1834: 
1835:   /**
1836:    *  memulai membuat tabel secara terpisah (harus diakhiri dengan partial_print_table_end)
1837:    * @param type $id
1838:    * - id dari tabel, tabel akan dibuat sesuai dengan id-nya
1839:    * @param type $mode
1840:    * - 1 -> echo, 2 -> return
1841:    * @return string
1842:    * - header <tabel>
1843:    */
1844:   function cetak_tabel_parsial_mulai($id=1, $mode=1)
1845:   {
1846:     $this->table_row[$id] = 0;
1847:     /* mode cetak, kirim data ke browser */
1848:     if ($mode == 1)
1849:     {
1850:         echo "<table border='1'>"; 
1851:     }
1852:     /* mode return */
1853:     else 
1854:     {
1855:         return "<table border='1'>";
1856:     }
1857:   }
1858: 
1859:   /**
1860:    * mengisi tabel secara terpisah (harus diakhiri dengan partial_print_table_end)
1861:    * @param type $data
1862:    * - isi tabel
1863:    * @param type $ignore_count
1864:    * - jumlah baris tidak perlu dihitung?
1865:    * @param type $id
1866:    * - id dari tabel, tabel akan dibuat sesuai dengan id-nya
1867:    * @param type $mode
1868:    * - 1 -> echo, 2 -> return
1869:    * @return string
1870:    * - <tr><td></td></tr>
1871:    */
1872:   function cetak_tabel_parsial($data, $ignore_count=false, $id=1, $mode=1)
1873:   {
1874:     $ret = "";
1875:     /* menghitung berapa dimensi array */
1876:     $dimensi  = $this->countdim($data);
1877:     /* jika data merupakan array satu dimensi */
1878:     if (is_array($data) && count($data > 0) && $dimensi == 1)
1879:     {
1880:       /* mode echo, cetak */
1881:       if ($mode == 1)
1882:       {
1883:         echo "<tr>";
1884:         foreach ($data as $idx => $cell)
1885:         {
1886:             echo "<td>$cell</td>";
1887:         }
1888:         echo "</tr>";
1889:       }
1890:       /* mode return, simpan ke dalam variabel */
1891:       else
1892:       {
1893:         $ret .= "<tr>";
1894:         foreach ($data as $idx => $cell)
1895:         {
1896:             $ret .= "<td>$cell</td>";
1897:         }
1898:         $ret .= "</tr>";
1899:       }
1900:       /* jika tidak ignore_count, simpan informasi jumlah baris */
1901:       if (!$ignore_count)
1902:       {
1903:           $this->table_row[$id]++;
1904:       }
1905:     }
1906:     /* jika data merupakan array dua dimensi (baris dan kolom) */
1907:     else if (is_array($data) && $dimensi == 2)
1908:     {
1909:       /* mode echo, cetak */
1910:       if ($mode == 1)
1911:       {
1912:         foreach ($data as $idx => $value)
1913:         {
1914:           echo "<tr>";
1915:           foreach ($value as $idx => $cell)
1916:           {
1917:               echo "<td>$cell</td>";
1918:           }
1919:           echo "</tr>";
1920:         }
1921:       }
1922:       /* mode return, simpan ke dalam variabel */
1923:       else
1924:       {
1925:         foreach ($data as $idx => $value)
1926:         {
1927:           $ret .= "<tr>";
1928:           foreach ($value as $idx => $cell)
1929:           {
1930:               $ret .= "<td>$cell</td>";
1931:           }
1932:           $ret .= "</tr>";
1933:         }
1934:       }
1935:       /* jika tidak ignore_count, simpan informasi jumlah baris */
1936:       if (!$ignore_count)
1937:       {
1938:           $this->table_row[$id]++;
1939:       }
1940:     }
1941:     /* bukan array, tidak dibuat tabel */
1942:     else
1943:     {
1944:         exit();
1945:     }
1946:     /* mode cetak, kirim data ke browser */
1947:     if ($mode == 1)
1948:     {
1949:         $this->kirim_buffer(); 
1950:     }
1951:     /* mode return */
1952:     else 
1953:     {
1954:         return $ret;
1955:     }
1956:   }
1957:   
1958:   /**
1959:    * mengisi tabel secara terpisah, tetapi hanya data indeks dari array (harus diakhiri dengan partial_print_table_end)
1960:    * @param type $data
1961:    * - isi tabel
1962:    * @param type $mode
1963:    * - 1 -> echo, 2 -> return
1964:    * @return string
1965:    * - <tr><td></td></tr>
1966:    */
1967:   function cetak_tabel_parsial_indeks($data, $mode=1)
1968:   {
1969:     $ret  = "";
1970:     /* jika data merupakan array */
1971:     if (is_array($data))
1972:     {
1973:       reset($data);
1974:       $arr  = current($data);
1975:       /* mode echo, cetak */
1976:       if ($mode == 1)
1977:       {
1978:         echo "<tr>";
1979:         foreach ($arr as $idx => $val)
1980:         {
1981:             echo "<td>$idx</td>";
1982:         }
1983:         echo "</tr>";
1984:       }
1985:       /* mode return */
1986:       else
1987:       {
1988:         $ret .= "<tr>";
1989:         foreach ($arr as $idx => $val)
1990:         {
1991:             $ret .= "<td>$idx</td>";
1992:         }
1993:         $ret .= "</tr>";
1994:       }
1995:     }
1996:     else
1997:     /* bukan array, tidak dibuat tabel */
1998:     {
1999:       exit();
2000:     }
2001:     /* bersih-bersih */
2002:     unset($arr);
2003:     /* mode cetak, kirim data ke browser */
2004:     if ($mode == 1) 
2005:     {
2006:         $this->kirim_buffer();
2007:     }
2008:     /* mode return */
2009:     else 
2010:     {
2011:         return $ret;
2012:     }
2013:   }
2014: 
2015:   /**
2016:    * menutup tabel terpisah (yang dimulai dengan partial_print_table_start)
2017:    * @param type $id
2018:    * - id dari tabel, tabel akan dibuat sesuai dengan id-nya
2019:    * @param type $mode
2020:    * - 1 -> echo, 2 -> return
2021:    * @return string
2022:    * - footer </tabel>
2023:    */
2024:   function cetak_tabel_parsial_akhiri($id=1, $mode=1)
2025:   {
2026:     /* mode cetak, kirim data ke browser */
2027:     if ($mode == 1)
2028:     {
2029:       echo "</table>";
2030:       echo "Terdapat ".$this->table_row[$id]." baris<br />";
2031:       $this->kirim_buffer();
2032:     }
2033:     /* mode return */
2034:     else
2035:     {
2036:       return  "</table>".
2037:               "Terdapat ".$this->table_row[$id]." baris<br />";
2038:     }
2039:   }
2040: 
2041:   /**
2042:    * membuat array yang memiliki kolom yang sama untuk semua baris, kolom baru berisi data kosong
2043:    * @param type $data
2044:    * - array dua dimensi, yang mungkin kolomnya tidak sama setiap barisnya, 
2045:    *   misal: arrayA = array(array("idx1"=>1, "idx2"=>2), array("idx1"=>3, "idx3"=>4));
2046:    * @return type
2047:    * - array yang memiliki kolom yang sama untuk semua baris, 
2048:    *   output dari permisalan data: arrayA = array(array("idx1"=>1, "idx2"=>2, "idx3" =>), array("idx1"=>3, "idx2"=>, "idx3"=>4));
2049:    */
2050:   function array_auto_fill($data)
2051:   {
2052:     /* buat daftar kolom, catat semua indeks (distinct) */
2053:     $idxList  = array();
2054:     foreach ($data as $element)
2055:     {
2056:       foreach ($element as $idx => $val)
2057:       {
2058:         /* jika indeks tidak ada di daftar kolom, maka ditambahkan ke daftar kolom */
2059:         if (!in_array($idx, $idxList))
2060:         {
2061:             $idxList[$idx]  = $idx;
2062:         }
2063:       }
2064:     }
2065:     /* buat array selebar idxList, kemudian sisipkan data jika pada baris tersebut terdapat kolomnya atau dikosongi jika pada baris tersebut tidak terdapat kolomnya */
2066:     reset($data);
2067:     $tempData = array();
2068:     foreach ($data as $idx => $val)
2069:     {
2070:       reset($idxList);
2071:       foreach ($idxList as $idx_ => $val_)
2072:       {
2073:           /* sisipkan data, jika tidak ada maka akan menyisipkan data kosong */
2074:           $tempData[$idx][$idx_]  = $val[$idx_];
2075:       }
2076:     }
2077:     $data = $tempData;
2078:     /* bersih-bersih */
2079:     unset($tempData);
2080:     unset($idxList);
2081:     return $data;
2082:   }
2083: }
2084: ?>
ws_pddikti API documentation generated by ApiGen