gwvplib/gwvpdatabase.php

   1 <?php
   2
   3 global $DB_CONNECTION;
   4 $DB_CONNECTION = false;
   5
   6 // i need to figure out how i do data encapsulation here. We'll support mysql and sqlite3 off the bat if we can - sqlite3 comes first tho
   7 function gwvp_dbCreateMysqlStructure()
   8 {
   9
  10 }
  11
  12 function gwvp_dbCreateSQLiteStructure($dbloc)
  13 {
  14         $usersql = '
  15                 CREATE TABLE "users" (
  16             "users_id" INTEGER PRIMARY KEY AUTOINCREMENT,
  17             "user_full_name" TEXT,
  18             "user_password" TEXT,
  19             "user_username" TEXT,
  20             "user_email" TEXT,
  21             "user_desc" TEXT,
  22             "user_status" TEXT
  23                 )';
  24
  25         $groupsql = '
  26                 CREATE TABLE groups (
  27             "groups_id" INTEGER PRIMARY KEY AUTOINCREMENT,
  28             "groups_name" TEXT,
  29             "groups_description" TEXT,
  30             "groups_is_admin" INTEGER,
  31                 "groups_owner_id" INTEGER
  32                 )';
  33
  34         $reposql = '
  35                 CREATE TABLE "repos" (
  36             "repos_id" INTEGER PRIMARY KEY AUTOINCREMENT,
  37             "repos_name" TEXT,
  38             "repos_description" TEXT,
  39             "repos_owner" INTEGER
  40                 )';
  41
  42         // this looks like null, <repoid>, <read|visible|write>, user:<uid>|group:<gid>|authed|anon
  43         // where authed = any authenticated user, anon = everyone (logged in, not logged in, etc)
  44         // read|visible|write = can clone from repo|can see repo exists and see description but not clone from it|can push to repo
  45         // TODO: is this sufficient? i have to think about it
  46         $repoperms = '
  47                 CREATE TABLE "repoperms" (
  48                 "repoperms_id" INTEGER PRIMARY KEY AUTOINCREMENT,
  49                 "repo_id" INTEGER,
  50                 "repoperms_type" TEXT,
  51                 "repoperms_ref" TEXT
  52         )';
  53
  54         $configsql = '
  55                 CREATE TABLE "config" (
  56             "config_name" TEXT,
  57             "config_value" TEXT
  58                 )';
  59
  60         $groupmemsql = '
  61                 CREATE TABLE "group_membership" (
  62             "groupmember_id" INTEGER PRIMARY KEY AUTOINCREMENT,
  63             "groupmember_groupid" INTEGER,
  64             "groupmember_userid" INTEGER
  65                 )';
  66
  67         try {
  68                 $DB_CONNECTION = new PDO("sqlite:$dbloc");
  69         } catch(PDOException $exep) {
  70                 error_log("execpt on db open");
  71                 return false;
  72         }
  73
  74
  75         $DB_CONNECTION->query($usersql);
  76         $DB_CONNECTION->query($groupsql);
  77         $DB_CONNECTION->query($reposql);
  78         $DB_CONNECTION->query($repoperms);
  79         $DB_CONNECTION->query($configsql);
  80         $DB_CONNECTION->query($groupmemsql);
  81 }
  82
  83 function gwvp_GetUserStatus($userid)
  84 {
  85         $conn = gwvp_ConnectDB();
  86
  87         $sql = "select user_status from users where users_id='$userid'";
  88
  89         $res = $conn->query($sql);
  90
  91         $return = null;
  92         foreach($res as $val) {
  93                 $spl = explode(";", $val);
  94
  95                 $return["statusid"] = $spl[0];
  96                 $return["extstatus"] = $spl[1];
  97         }
  98
  99 }
 100
 101 function gwvp_SetUserStatus($userid, $status, $extendedstatus=null)
 102 {
 103         /*
 104          * user statues
 105          * 0 - all good
 106          * 1 - locked
 107          * 2 - password locked
 108          * 3 - awaiting registration completion
 109          * 4 - awaiting password reset
 110          * where use status = 3,4 the key for unlock is set as the extended status
 111          * i.e. if a user goes thru registration, when the validation email gets to
 112          * them they'll have a key in their email (128 or 256 bit), thats what
 113          * the extended status field is used for
 114          */
 115
 116         $conn = gwvp_ConnectDB();
 117
 118         if($extendedstatus != null) {
 119                 $sql = "update users set user_status='$status;$extendedstatus' where users_id='$userid'";
 120         } else {
 121                 $sql = "update users set user_status='$status;0' where users_id='$userid'";
 122         }
 123
 124         return $conn->query($sql);
 125
 126 }
 127
 128 function gwvp_forceDisconnect()
 129 {
 130
 131         global $DB_CONNECTION;
 132
 133         $DB_CONNECTION = false;
 134 }
 135
 136
 137 function gwvp_getConfigVal($confname)
 138 {
 139         /*
 140          *      $configsql = '
 141                 CREATE TABLE "config" (
 142             "config_name" TEXT,
 143             "config_value" TEXT
 144                 )';
 145
 146          */
 147
 148         $conn = gwvp_ConnectDB();
 149
 150         $sql = "select * from config where config_name='$confname'";
 151
 152         $res = $conn->query($sql);
 153
 154         $return = null;
 155         foreach($res as $val) {
 156                 $return = $val;
 157         }
 158
 159 }
 160
 161 function gwvp_eraseConfigVal($confname)
 162 {
 163         /*
 164          *      $configsql = '
 165                 CREATE TABLE "config" (
 166             "config_name" TEXT,
 167             "config_value" TEXT
 168                 )';
 169
 170          */
 171
 172         $conn = gwvp_ConnectDB();
 173
 174         $sql = "delete from config where config_name='$confname'";
 175
 176         return $conn->query($sql);
 177 }
 178
 179 function gwvp_setConfigVal($confname, $confval)
 180 {
 181         /*
 182          *      $configsql = '
 183                 CREATE TABLE "config" (
 184             "config_name" TEXT,
 185             "config_value" TEXT
 186                 )';
 187
 188          */
 189         gwvp_eraseConfigVal($confname);
 190
 191         $conn = gwvp_ConnectDB();
 192
 193         $sql = "insert into config values('$confname', '$confval')";
 194
 195         return $conn->query($sql);
 196 }
 197
 198
 199 function gwvp_isDBSetup()
 200 {
 201         // for sqlite, we just check if the db exists, for everyone else, we check for a conneciton and go yay or nay
 202         global $WEB_ROOT_FS, $BASE_URL, $repo_base, $data_directory, $db_type, $db_url;
 203
 204         if($db_type == "sqlite") {
 205                 if(file_exists($db_url)) return true;
 206                 else return false;
 207         }
 208
 209         // TODO now for the connectables
 210         // gwvp_ConnectDB();
 211 }
 212
 213 function gwvp_ConnectDB()
 214 {
 215         global $WEB_ROOT_FS, $BASE_URL, $repo_base, $data_directory, $db_type, $db_name, $DB_CONNECTION;
 216
 217         // first check if $DB_CONNECTION IS live
 218         if($DB_CONNECTION != false) return $DB_CONNECTION;
 219
 220         if($db_type == "sqlite") {
 221                 $db_url = $db_name;
 222                 if(!file_exists($db_name)) {
 223                         error_log("$db_name does not exist - problem");
 224                 }
 225         }
 226
 227         // and here we go with pdo.
 228         error_log("attmpting to open db, $db_type:$db_url");
 229         try {
 230                 $DB_CONNECTION = new PDO("$db_type:$db_url");
 231         } catch(PDOException $exep) {
 232                 error_log("execpt on db open");
 233                 return false;
 234         }
 235
 236         return $DB_CONNECTION;
 237 }
 238
 239 // TODO: we have to define what "Status" is
 240 function gwvp_createUser($email, $fullname, $password, $username, $desc, $status)
 241 {
 242         $conn = gwvp_ConnectDB();
 243
 244         // TODO: change from sha1
 245         $shapass = sha1($password);
 246         //error_log("Create user called with $email");
 247         $sql = "insert into users values (null, '$fullname', '$shapass', '$username', '$email', '$desc', '$status')";
 248         error_log("Creating user, $sql");
 249         return $conn->query($sql);
 250         /*
 251          *          "users_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 252          "user_full_name" TEXT,
 253          "user_password" TEXT,
 254          "user_username" TEXT,
 255          "user_email" TEXT,
 256          "user_desc" TEXT,
 257          "user_status" INTEGER
 258
 259          */
 260 }
 261
 262 function gwvp_getUser($username=null, $email=null, $id=null)
 263 {
 264         $conn = gwvp_ConnectDB();
 265
 266         if($username != null) {
 267                 $res = $conn->query("select * from users where user_username='$username'");
 268         } else if($email != null) {
 269                 $res = $conn->query("select * from users where user_email='$email'");
 270         } else if($id != null) {
 271                 $res = $conn->query("select * from users where users_id='$id'");
 272         } else return false;
 273
 274         $returns = false;
 275         foreach($res as $u_res) {
 276                 $returns["id"] = $u_res["users_id"];
 277                 $returns["fullname"] = $u_res["user_full_name"];
 278                 $returns["password"] = $u_res["user_password"];
 279                 $returns["username"] = $u_res["user_username"];
 280                 $returns["email"] = $u_res["user_email"];
 281                 $returns["desc"] = $u_res["user_desc"];
 282                 $returns["status"] = $u_res["user_status"];
 283         }
 284
 285         return $returns;
 286
 287 }
 288
 289 function gwvp_getRepoOwner($repoid)
 290 {
 291         $conn = gwvp_ConnectDB();
 292
 293         $sql = "select repos_owner from repos where repos_id='$repoid'";
 294
 295         $res = $conn->query($sql);
 296
 297         $return = false;
 298         foreach($res as $rown) {
 299                 $return = $rown["repos_owner"];
 300         }
 301         return $return;
 302 }
 303
 304 function gwvp_getOwnedRepos($userid = null, $username = null)
 305 {
 306         $conn = gwvp_ConnectDB();
 307
 308         if($username != null) {
 309                 $details = gwvp_getUser($username);
 310                 $uid = $details["id"];
 311                 $sql = "select * from repos where repos_owner='$uid'";
 312                 $res = $conn->query($sql);
 313                 error_log("sql: $sql");
 314         } else if($userid != null) {
 315                 $sql = "select * from repos where repos_owner='$userid'";
 316                 $res = $conn->query($sql);
 317                 error_log("sql: $sql");
 318         } else return false;
 319
 320         /*
 321          *              CREATE TABLE "repos" (
 322             "repos_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 323             "repos_name" TEXT,
 324             "repos_description" TEXT,
 325             "repos_owner" INTEGER
 326                 )';
 327
 328          */
 329
 330         $returns = false;
 331         $rn = 0;
 332         foreach($res as $u_res) {
 333                 $returns[$rn]["id"] = $u_res["repos_id"];
 334                 $returns[$rn]["name"] = $u_res["repos_name"];
 335                 $returns[$rn]["description"] = $u_res["repos_description"];
 336                 $rn++;
 337         }
 338
 339         return $returns;
 340 }
 341
 342 function gwvp_getUsers()
 343 {
 344         $conn = gwvp_ConnectDB();
 345
 346         $res = $conn->query("select * from users");
 347
 348         $returns = false;
 349         $rn = 0;
 350         foreach($res as $u_res) {
 351                 $returns[$rn]["id"] = $u_res["users_id"];
 352                 $returns[$rn]["fullname"] = $u_res["user_full_name"];
 353                 $returns[$rn]["password"] = $u_res["user_password"];
 354                 $returns[$rn]["username"] = $u_res["user_username"];
 355                 $returns[$rn]["email"] = $u_res["user_email"];
 356                 $returns[$rn]["desc"] = $u_res["user_desc"];
 357                 $returns[$rn]["status"] = $u_res["user_status"];
 358                 $rn++;
 359         }
 360
 361         return $returns;
 362 }
 363
 364 function gwvp_deleteUser($email)
 365 {
 366         $conn = gwvp_ConnectDB();
 367
 368         $sql = "delete from users where user_email='$email'";
 369
 370         $conn->query($sql);
 371 }
 372
 373 function gwvp_createGroup($group_name, $group_desc, $is_admin, $owner_id)
 374 {
 375         $conn = gwvp_ConnectDB();
 376
 377         /*
 378          *              CREATE TABLE groups (
 379          "groups_id" INTEGER,
 380          "groups_name" TEXT,
 381          "groups_is_admin" INTEGER,
 382                 "groups_owner_id" INTEGER
 383                 )';
 384
 385          */
 386         if($is_admin) {
 387                 $is_admin_t = 1;
 388         } else {
 389                 $is_admin_t = 0;
 390         }
 391         $sql = "insert into groups values( null, '$group_name', '$group_desc', '$is_admin_t', '$owner_id')";
 392
 393
 394         $conn->query($sql);
 395
 396 }
 397
 398 function gwvp_deleteGroup($groupname)
 399 {
 400         $conn = gwvp_ConnectDB();
 401
 402         $sql = "delete from groups where groups_name='$groupname'";
 403
 404         $conn->query($sql);
 405 }
 406
 407 function gwvp_getGroupsForUser($email = null, $userid = null)
 408 {
 409         $conn = gwvp_ConnectDB();
 410
 411         /*
 412          select g.groups_name from
 413          group_membership gm, groups g, users u
 414          where
 415          gm.groupmember_userid=u.users_id and
 416          u.user_email='$email' and
 417          gm.groupmember_groupid=g.groups_id and
 418          g.groups_name='$groupname'
 419          */
 420         if($email != null) {
 421                 $sql = "
 422                                 select g.groups_name from
 423                                         group_membership gm, groups g, users u
 424                                 where
 425                                         gm.groupmember_userid=u.users_id and
 426                                         u.user_email='$email' and
 427                                         gm.groupmember_groupid=g.groups_id
 428                 ";
 429         } else if($userid != null) {
 430                 $sql = "
 431                                 select g.groups_name from
 432                                         group_membership gm, groups g, users u
 433                                 where
 434                                         gm.groupmember_userid=u.users_id and
 435                                         u.users_id='$userid' and
 436                                         gm.groupmember_groupid=g.groups_id
 437                 ";
 438         } else return false;
 439
 440         $res = $conn->query($sql);
 441
 442         $return = false;
 443         $rn = 0;
 444         foreach($res as $u_res) {
 445                 $return[$rn] = $u_res[0];
 446                 $rn++;
 447         }
 448
 449         return $return;
 450 }
 451
 452 function gwvp_getGroupsOwnedByUser($email)
 453 {
 454         $conn = gwvp_ConnectDB();
 455
 456         /*
 457          select g.groups_name from
 458          group_membership gm, groups g, users u
 459          where
 460          gm.groupmember_userid=u.users_id and
 461          u.user_email='$email' and
 462          gm.groupmember_groupid=g.groups_id and
 463          g.groups_name='$groupname'
 464          */
 465
 466         $sql = "
 467                         select g.groups_name from
 468                                 groups g, users u
 469                         where
 470                                 u.user_email='$email' and
 471                                 u.users_id=g.groups_owner_id
 472         ";
 473
 474         $res = $conn->query($sql);
 475
 476         $return = false;
 477         $rn = 0;
 478         foreach($res as $u_res) {
 479                 $return[$rn] = $u_res[0];
 480                 $rn++;
 481         }
 482
 483         return $return;
 484
 485 }
 486
 487 function gwvp_groupOwner($groupname)
 488 {
 489         $conn = gwvp_ConnectDB();
 490
 491         $sql = "select u.user_email from users u, groups g where g.groups_name='$groupname' and g.groups_owner_id=u.users_id";
 492
 493         $res = $conn->query($sql);
 494         $return = false;
 495         foreach($res as $u_res) {
 496                 $return = $u_res[0];
 497         }
 498
 499         return $return;
 500 }
 501
 502 function gwvp_getGroups()
 503 {
 504         $conn = gwvp_ConnectDB();
 505
 506         $res = $conn->query("select * from groups");
 507
 508         $returns = false;
 509         $rn = 0;
 510         foreach($res as $u_res) {
 511                 $returns[$rn]["id"] = $u_res["groups_id"];
 512                 $returns[$rn]["name"] = $u_res["groups_name"];
 513                 if($u_res["groups_is_admin"]=="1") $return[$rn]["admin"] = true;
 514                 else $return[$rn]["admin"] = false;
 515                 $returns[$rn]["admin"] = $u_res["groups_is_admin"];
 516                 $returns[$rn]["ownerid"] = $u_res["groups_owner_id"];
 517                 $rn++;
 518         }
 519
 520         return $returns;
 521 }
 522
 523 function gwvp_getGroupId($groupname)
 524 {
 525         $conn = gwvp_ConnectDB();
 526
 527         $sql = "select groups_id from groups where groups_name='$groupname'";
 528
 529         $res = $conn->query($sql);
 530         $return = false;
 531         foreach($res as $u_res) {
 532                 $return = $u_res["groups_id"];
 533         }
 534
 535         return $return;
 536 }
 537
 538 function gwvp_getGroup($gid = null, $gname = null)
 539 {
 540         /*
 541          *      $groupsql = '
 542                 CREATE TABLE groups (
 543             "groups_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 544             "groups_name" TEXT,
 545             "groups_is_admin" INTEGER,
 546                 "groups_owner_id" INTEGER
 547                 )';
 548
 549          */
 550         $conn = gwvp_ConnectDB();
 551
 552         if($gid != null) {
 553                 $sql = "select * from groups where groups_id='$gid'";
 554         } else if ($gname != null) {
 555                 $sql = "select * from groups where groups_name='$gname'";
 556         } else return false;
 557
 558         $res = $conn->query($sql);
 559         $return = false;
 560         foreach($res as $u_res) {
 561                 $return["id"] = $u_res["groups_id"];
 562                 $return["name"] = $u_res["groups_name"];
 563                 if($u_res["groups_is_admin"] == 1) {
 564                         $return["isadmin"] = true;
 565                 } else {
 566                         $return["isadmin"] = false;
 567                 }
 568                 $return["ownerid"] = $u_res["groups_owner_id"];
 569                 $return["description"] = $u_res["groups_description"];
 570         }
 571
 572         return $return;
 573 }
 574
 575 function gwvp_getUserId($useremail=null, $username = null)
 576 {
 577         $conn = gwvp_ConnectDB();
 578
 579         if($useremail != null) {
 580                 $sql = "select users_id from users where user_email='$useremail'";
 581         } else if($username != null) {
 582                 $sql = "select users_id from users where user_username='$username'";
 583         } else return false;
 584
 585         $res = $conn->query($sql);
 586         $return = false;
 587         foreach($res as $u_res) {
 588                 $return = $u_res["users_id"];
 589         }
 590
 591         return $return;
 592 }
 593
 594 function gwvp_getUserName($id = null, $email=null)
 595 {
 596         $conn = gwvp_ConnectDB();
 597
 598         if($email != null) {
 599                 $sql = "select user_username from users where user_email='$email'";
 600         } else if($id != null) {
 601                 $sql = "select user_username from users where users_id='$id'";
 602         } else return false;
 603
 604         $res = $conn->query($sql);
 605         $return = false;
 606         foreach($res as $u_res) {
 607                 $return = $u_res["user_username"];
 608         }
 609
 610         return $return;
 611 }
 612
 613
 614 function gwvp_getUserEmail($id)
 615 {
 616         $conn = gwvp_ConnectDB();
 617
 618         $sql = "select user_email from users where users_id='$id'";
 619
 620         $res = $conn->query($sql);
 621         $return = false;
 622         foreach($res as $u_res) {
 623                 $return = $u_res["user_email"];
 624         }
 625
 626         return $return;
 627 }
 628
 629 function gwvp_deleteGroupMemberByID($uid, $gid)
 630 {
 631         $conn = gwvp_ConnectDB();
 632
 633         /*
 634          *              CREATE TABLE "group_membership" (
 635          "groupmember_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 636          "groupmember_groupid" INTEGER,
 637          "groupmember_userid" INTEGER
 638
 639          */
 640         $sql = "delete from group_membership where groupmember_groupid='$gid' and  groupmember_userid='$uid'";
 641
 642         $conn->query($sql);
 643
 644         return true;
 645 }
 646
 647
 648 function gwvp_addGroupMemberByID($uid, $gid)
 649 {
 650         $conn = gwvp_ConnectDB();
 651
 652         /*
 653          *              CREATE TABLE "group_membership" (
 654          "groupmember_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 655          "groupmember_groupid" INTEGER,
 656          "groupmember_userid" INTEGER
 657
 658          */
 659         $sql = "insert into group_membership values (null, '$gid', '$uid')";
 660
 661         $conn->query($sql);
 662
 663         return true;
 664 }
 665
 666
 667 function gwvp_addGroupMember($email, $groupname)
 668 {
 669         $conn = gwvp_ConnectDB();
 670
 671         $uid = gwvp_getUserId($email);
 672         $gid = gwvp_getGroupId($groupname);
 673
 674         /*
 675          *              CREATE TABLE "group_membership" (
 676          "groupmember_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 677          "groupmember_groupid" INTEGER,
 678          "groupmember_userid" INTEGER
 679
 680          */
 681         if($uid!=false&&$gid!=false) gwvp_addGroupMemberByID($uid, $gid);
 682         else return false;
 683
 684         return true;
 685 }
 686
 687 function gwvp_IsGroupMember($email, $groupname)
 688 {
 689         $conn = gwvp_ConnectDB();
 690
 691         // i think this is right
 692         $sql = "
 693                         select count(*) from
 694                                 group_membership gm, groups g, users u
 695                         where
 696                                 gm.groupmember_userid=u.users_id and
 697                                 u.user_email='$email' and
 698                                 gm.groupmember_groupid=g.groups_id and
 699                                 g.groups_name='$groupname'
 700                         ";
 701
 702         $res = $conn->query($sql);
 703         $result = 0;
 704         foreach($res as $u_res) {
 705                 $result = $u_res[0];
 706         }
 707
 708         if($result == 0) return false;
 709         if($result == 1) return true;
 710 }
 711
 712 function gwvp_IsUserAdmin($email=null, $username = null, $userid = null)
 713 {
 714         $conn = gwvp_ConnectDB();
 715
 716
 717         // TODO: clean this up, this should be a single query - idiot
 718         if($email != null) {
 719                 $id = gwvp_getUserId($email);
 720                 $sql = "select groupmember_groupid from group_membership where groupmember_userid='$id'";
 721         } else if($userid != null) {
 722                 $sql = "select groupmember_groupid from group_membership where groupmember_userid='$userid'";
 723         } else if($username != null) {
 724                 $id = gwvp_getUserId(null, $username);
 725                 $sql = "select groupmember_groupid from group_membership where groupmember_userid='$id'";
 726         } else return false;
 727
 728         $res = $conn->query($sql);
 729         $rn = 0;
 730         $gid = false;
 731         foreach($res as $u_res) {
 732                 $gid[$rn] = $u_res["groupmember_groupid"];
 733                 $rn++;
 734         }
 735
 736         if($gid !== false) foreach($gid as $gid_t) {
 737                 /*
 738                  *              CREATE TABLE groups (
 739                  "groups_id" INTEGER,
 740                  "groups_name" TEXT,
 741                  "groups_is_admin" INTEGER,
 742                  "groups_owner_id" INTEGER
 743                  )';
 744
 745                  */
 746
 747                 $sql = "select groups_is_admin from groups where groups_id='$gid_t'";
 748                 $res = $conn->query($sql);
 749                 foreach($res as $u_res) {
 750                         if($u_res["groups_is_admin"] == "1") return true;
 751                 }
 752         }
 753
 754         return false;
 755 }
 756
 757 function gwvp_ModifyUser($userid, $email=null, $fullname=null, $password=null, $username=null, $desc=null, $status=null)
 758 {
 759         /*
 760          *          "users_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 761          "user_full_name" TEXT,
 762          "user_password" TEXT,
 763          "user_username" TEXT,
 764          "user_email" TEXT,
 765          "user_desc" TEXT,
 766          "user_status" INTEGER
 767
 768          */
 769
 770         $conn = gwvp_ConnectDB();
 771
 772         if($email != null) {
 773                 $sql = "update users set user_email='$email' where users_id='$userid'";
 774                 $conn->query($sql);
 775         }
 776
 777         if($fullname != null) {
 778                 $sql = "update users set user_full_name='$fullname' where users_id='$userid'";
 779                 $conn->query($sql);
 780         }
 781
 782         if($password != null) {
 783                 $shapass = sha1($password);
 784                 $sql = "update users set user_password='$shapass' where users_id='$userid'";
 785                 $conn->query($sql);
 786         }
 787
 788         if($username != null) {
 789                 $sql = "update users set user_username='$username' where users_id='$userid'";
 790                 $conn->query($sql);
 791         }
 792
 793         if($desc != null) {
 794                 $sql = "update users set user_desc='$desc' where users_id='$userid'";
 795                 $conn->query($sql);
 796         }
 797
 798         if($status != null) {
 799                 $sql = "update users set user_status='$status' where users_id='$userid'";
 800                 $conn->query($sql);
 801         }
 802
 803         return true;
 804 }
 805
 806
 807 function gwvp_ModifyGroup($groupid, $groupname = null, $group_is_admin = null, $groups_owner_id = null)
 808 {
 809         /*
 810          *              CREATE TABLE groups (
 811          "groups_id" INTEGER,
 812          "groups_name" TEXT,
 813          "groups_is_admin" INTEGER,
 814                 "groups_owner_id" INTEGER
 815                 )';
 816
 817          */
 818         $conn = gwvp_ConnectDB();
 819
 820         if($groupname != null) {
 821                 $sql = "update groups set groups_name='$groupname' where groups_id='$groupid'";
 822                 $conn->query($sql);
 823         }
 824
 825         if($group_is_admin != null) {
 826                 $sql = "update groups set groups_is_admin='$group_is_admin' where groups_id='$groupid'";
 827                 $conn->query($sql);
 828         }
 829
 830         if($groups_owner_id != null) {
 831                 $sql = "update groups set groups_owner_id='$groups_owner_id' where groups_id='$groupid'";
 832                 $conn->query($sql);
 833         }
 834
 835         return true;
 836 }
 837
 838 function gwvp_GetRepoList()
 839 {
 840         $conn = gwvp_ConnectDB();
 841
 842         /*
 843          *      $reposql = '
 844                 CREATE TABLE "repos" (
 845                 "repos_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 846                 "repos_name" TEXT,
 847                 "repos_description" TEXT,
 848                 "repos_owner" INTEGER
 849                 )';
 850
 851          */
 852
 853         $sql = "select * from repos";
 854
 855         $res = $conn->query($sql);
 856
 857         $return = false;
 858         $rn = 0;
 859         foreach($res as $u_res) {
 860                 $return[$rn]["id"] = $u_res["repos_id"];
 861                 $return[$rn]["name"] = $u_res["repos_name"];
 862                 $return[$rn]["description"] = $u_res["repos_description"];
 863                 $return[$rn]["owner"] = $u_res["repos_owner"];
 864                 $rn++;
 865         }
 866
 867         return $return;
 868 }
 869
 870 function gwvp_AddRepo($reponame, $repodesc, $repoowner, $defaultperms = 0)
 871 {
 872         $conn = gwvp_ConnectDB();
 873
 874         $sql = "insert into repos values (null, '$reponame', '$repodesc', '$repoowner')";
 875
 876         $conn->query($sql);
 877
 878         $sql = "select repos_id from repos where repos_name='$reponame'";
 879         $res = $conn->query($sql);
 880         $rid = -1;
 881         foreach($res as $repos) {
 882                 $rid = $repos["repos_id"];
 883         }
 884         /*
 885          *              CREATE TABLE "repoperms" (
 886                 "repoperms_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 887                 "repo_id" INTEGER,
 888                 "repoperms_type" TEXT,
 889                 "repoperms_ref" TEXT
 890
 891          */
 892
 893         /*
 894          * // default perms:
 895 // 0 - anyone can clone/read, only owner can write
 896 // 1 - noone can clone/read, repo is visible (i.e. name), only owner can read/write repo
 897 // 2 - only owner can see anything
 898
 899          */
 900
 901         switch($defaultperms) {
 902                 case "1":
 903                         gwvp_addRepoPermission($rid, "visible", "anon");
 904                         break;
 905                 case "2":
 906                         // by 2, we do nothing, owner already has full perms
 907                         break;
 908                 default: // 0
 909                         gwvp_addRepoPermission($rid, "read", "anon");
 910
 911         }
 912 }
 913
 914 function gwvp_getRepoPermissions($repoid)
 915 {
 916         /*
 917          *      // this looks like null, <repoid>, <read|visible|write>, user:<uid>|group:<gid>|authed|anon
 918         // where authed = any authenticated user, anon = everyone (logged in, not logged in, etc)
 919         // read|visible|write = can clone from repo|can see repo exists and see description but not clone from it|can push to repo
 920         // TODO: is this sufficient? i have to think about it
 921         $repoperms = '
 922                 CREATE TABLE "repoperms" (
 923                 "repoperms_id" INTEGER PRIMARY KEY AUTOINCREMENT,
 924                 "repo_id" INTEGER,
 925                 "repoperms_type" TEXT,
 926                 "repoperms_ref" TEXT
 927         )';
 928
 929          */
 930         $conn = gwvp_ConnectDB();
 931
 932         $sql = "select * from repoperms where repo_id='$repoid'";
 933
 934         $res = $conn->query($sql);
 935
 936         $returns = false;
 937         $rn = 0;
 938         foreach($res as $perm) {
 939                 $returns[$rn]["permid"] = $perm["repoperms_id"];
 940                 $returns[$rn]["type"] = $perm["repoperms_type"];
 941                 $returns[$rn]["ref"] = $perm["repoperms_ref"];
 942                 $rn++;
 943         }
 944
 945         return $returns;
 946 }
 947
 948 function gwvp_addRepoPermission($repoid, $permtype, $permref)
 949 {
 950         $conn = gwvp_ConnectDB();
 951
 952         $sql = "insert into repoperms values(null, '$repoid', '$permtype', '$permref')";
 953
 954         return $conn->query($sql);
 955 }
 956 /* functions we'll need to access data:
 957  *
 958  * getUsers(pattern)
 959  * getUserData(username)
 960  * getGroups(pattern)
 961  * getGroupData(groupname)
 962  * modifyGroup(...)
 963  * addGroupMember(...)
 964  * deleteGroupMember(...)
 965  *
 966  * createUser(...)
 967  * deleteUser(...)
 968  * modifyUser(...)
 969  * createRepo(...)
 970  * deleteRepo(...)
 971  * getRepos()
 972  */
 973
 974
 975
 976 ?>