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