flaskr.py.bak

   1 # all the imports
   2 import os
   3 import sqlite3
   4 from flask import Flask, request, session, g, redirect, url_for, abort, \
   5      render_template, flash
   6
   7 """ ---------------- ---------------- App Init ---------------- ---------------- """
   8 # create our little application :)
   9 app = Flask(__name__)
  10 app.config.from_object(__name__)
  11
  12 # Load default config and override config from an environment variable
  13 app.config.update(dict(
  14     DATABASE=os.path.join(app.root_path, 'flaskr.db'),
  15     SECRET_KEY='development key',
  16     USERNAME='admin',
  17     PASSWORD='testing'
  18 ))
  19 app.config.from_envvar('FLASKR_SETTINGS', silent=True)
  20
  21 """ ---------------- ---------------- Database Functions ---------------- ---------------- """
  22 def connect_db():
  23     #Connects to the specific database
  24     rv = sqlite3.connect(app.config['DATABASE'])
  25     rv.row_factory = sqlite3.Row
  26     return rv
  27
  28 def get_db():
  29     #Opens a new database connection if there is none yet for the current application context
  30     if not hasattr(g, 'sqlite_db'):
  31         g.sqlite_db = connect_db()
  32     return g.sqlite_db
  33
  34 @app.teardown_appcontext
  35 def close_db(error):
  36     #Closes the database again at the end of the request
  37     if hasattr(g, 'sqlite_db'):
  38         g.sqlite_db.close()
  39
  40
  41 def init_db():
  42     db = get_db()
  43     with app.open_resource('schema.sql', mode='r') as f:
  44         db.cursor().executescript(f.read())
  45     #db.execute('PRAGMA FOREIGN_KEYS=ON')
  46     #db.execute('PRAGMA foreign_keys  = "1"')
  47     db.commit()
  48
  49 @app.cli.command('initdb')
  50 def initdb_command():
  51     #Initializes the database
  52     init_db()
  53     print 'Initialized the database.'
  54
  55
  56 """ ---------------- ---------------- General Functions ---------------- ---------------- """
  57 #Login
  58 @app.route('/login', methods=['GET', 'POST'])
  59 def login():
  60     error = None
  61     if request.method == 'POST':
  62         if request.form['username'] != app.config['USERNAME']:
  63             error = 'Invalid username'
  64         elif request.form['password'] != app.config['PASSWORD']:
  65             error = 'Invalid password'
  66         else:
  67             session['logged_in'] = True
  68             flash('You were logged in')
  69
  70             return redirect(url_for('item_list'))
  71     return render_template('login.html', error=error)
  72
  73 #Logout
  74 @app.route('/logout')
  75 def logout():
  76     session.pop('logged_in', None)
  77     flash('You were logged out')
  78     return redirect(url_for('item_list'))
  79
  80 #Upload
  81 @app.route("/upload", methods=["POST"])
  82 def upload():
  83     uploaded_files = flask.request.files.getlist("file[]")
  84     print uploaded_files
  85     return ""
  86
  87 #Get row count of a table
  88 def get_next_row(currentTable):
  89     sql_string = open('sql/select_row_count.sql', 'r').read()
  90     sql_string = sql_string.replace("currentTable", currentTable)
  91     db = get_db()
  92     cur = db.execute(sql_string)
  93     row_count = cur.fetchone()
  94     return row_count
  95
  96 """ ---------------- ---------------- Main Routes ---------------- ---------------- """
  97 #Display Data - Dashboard
  98 @app.route('/')
  99 def dashboard():
 100     return render_template('dashboard.html')
 101
 102 """ ---------------- ---------------- List Parts ---------------- ---------------- """
 103 #Select all parts and display webpage
 104 @app.route('/pcparts_list')
 105 def pcparts_list():
 106         sql_string = open('sql/select_all_pcparts.sql', 'r').read()
 107         db = get_db()
 108         cur = db.execute(sql_string)
 109         items = cur.fetchall()
 110         abc = db.execute('PRAGMA foreign_keys')
 111         abcX = abc.fetchall()
 112         print "FOREIGN KEY STATUS:"
 113         print abcX
 114         print "-----------------------"
 115         abc = db.execute('PRAGMA foreign_keys=ON')
 116         abc = db.execute('PRAGMA foreign_keys')
 117         abcY = abc.fetchall()
 118         print "FOREIGN KEY STATUS:"
 119         print abcY
 120         print "-----------------------"
 121         #Display the page
 122         #   items ==> list of columns and respective rows for all PC parts
 123         return render_template('pcparts_list.html', items=items)
 124
 125
 126 #Select all builds and display webpage
 127 @app.route('/pcparts_listBuilds')
 128 def pcparts_listBuilds():
 129         #Select all builds
 130         pcBuildList = get_pcBuildList()
 131         #Display the page
 132         #   pcBuildList ==> list of columns and respective rows for all PC builds
 133         return render_template('pcparts_listBuilds.html', pcBuildList=pcBuildList)
 134
 135 #Get a part
 136 def get_part(pcPartId):
 137         sql_string = open('sql/select_part.sql', 'r').read()
 138         db = get_db()
 139         abc = db.execute('PRAGMA foreign_keys=ON')
 140         cur = db.execute(sql_string, [pcPartId])
 141         part_row = cur.fetchone()
 142         #Return row of part details
 143         return part_row
 144
 145
 146 #Get a part's details
 147 def get_part_details(pcPartId, pcPartType):
 148         sql_string = open('sql/select_part_details.sql', 'r').read()
 149         sql_string = sql_string.replace("tableName", pcPartType)
 150         print "sql_string"
 151         print sql_string
 152         print "sql_string"
 153         db = get_db()
 154         abc = db.execute('PRAGMA foreign_keys=ON')
 155         cur = db.execute(sql_string, [pcPartId])
 156         part_details_row = cur.fetchone()
 157         #Return row of part details
 158         return part_details_row
 159
 160 #Display Data - a part's details
 161 @app.route('/pcparts_list/<int:pcPartId>/<pcPartType>/part_details/')
 162 def part_details(pcPartId, pcPartType):
 163         selected_row = get_part_details(pcPartId, pcPartType)
 164         #Display the page
 165         #   pcPartId ==> current part id
 166         #   selected_row ==> the part's details
 167         return render_template('/pcparts/select_ssd.html', pcPartId=pcPartId, selected_row=selected_row, pcPartType=pcPartType)
 168
 169 def fetch_parts():
 170         db = get_db()
 171         abc = db.execute('PRAGMA foreign_keys=ON')
 172
 173         #Fetch Mobo List
 174         sql_string = open('sql/select_moboList.sql', 'r').read()
 175         result = db.execute(sql_string)
 176         moboList = result.fetchall()
 177
 178         #Fetch Case List
 179         sql_string = open('sql/select_caseList.sql', 'r').read()
 180         result = db.execute(sql_string)
 181         caseList = result.fetchall()
 182
 183         #Fetch PSU List
 184         sql_string = open('sql/select_psuList.sql', 'r').read()
 185         result = db.execute(sql_string)
 186         psuList = result.fetchall()
 187
 188         #Fetch RAM List
 189         sql_string = open('sql/select_ramList.sql', 'r').read()
 190         result = db.execute(sql_string)
 191         ramList = result.fetchall()
 192
 193         #Fetch GPU List
 194         sql_string = open('sql/select_gpuList.sql', 'r').read()
 195         result = db.execute(sql_string)
 196         gpuList = result.fetchall()
 197
 198         #Fetch SSD List
 199         sql_string = open('sql/select_ssdList.sql', 'r').read()
 200         result = db.execute(sql_string)
 201         ssdList = result.fetchall()
 202
 203         #Fetch HDD List
 204         sql_string = open('sql/select_hddList.sql', 'r').read()
 205         result = db.execute(sql_string)
 206         hddList = result.fetchall()
 207
 208         #Fetch CPU List
 209         sql_string = open('sql/select_cpuList.sql', 'r').read()
 210         result = db.execute(sql_string)
 211         cpuList = result.fetchall()
 212
 213         #Fetch CPU Cooling List
 214         sql_string = open('sql/select_cpuCoolList.sql', 'r').read()
 215         result = db.execute(sql_string)
 216         cpuCoolList = result.fetchall()
 217
 218         #Fetch Fan List
 219         sql_string = open('sql/select_fanList.sql', 'r').read()
 220         result = db.execute(sql_string)
 221         fanList = result.fetchall()
 222
 223         #Fetch LED Kit List
 224         sql_string = open('sql/select_ledkitList.sql', 'r').read()
 225         result = db.execute(sql_string)
 226         ledkitList = result.fetchall()
 227
 228         #Fetch OS List
 229         sql_string = open('sql/select_osList.sql', 'r').read()
 230         result = db.execute(sql_string)
 231         osList = result.fetchall()
 232
 233         dataList = []
 234         dataList.append(moboList)
 235         dataList.append(caseList)
 236         dataList.append(psuList)
 237         dataList.append(ramList)
 238         dataList.append(gpuList)
 239         dataList.append(ssdList)
 240         dataList.append(hddList)
 241         dataList.append(cpuList)
 242         dataList.append(cpuCoolList)
 243         dataList.append(fanList)
 244         dataList.append(ledkitList)
 245         dataList.append(osList)
 246
 247         return dataList
 248
 249
 250
 251 #
 252 #
 253 # check out ebay API
 254 # check out ebay API
 255 # check out ebay API
 256 # check out ebay API
 257 #
 258 #
 259 """ ---------------- ---------------- PC Builds ---------------- ----------------"""
 260 """ ---------------- Add PC Build  ----------------"""
 261 #Display Form - Add a New Build
 262 @app.route('/pcparts_addBuild.html', methods=['GET', 'POST'])
 263 def pcparts_addBuild():
 264         db = get_db()
 265         abc = db.execute('PRAGMA foreign_keys=ON')
 266
 267         #Fetch Mobo List
 268         sql_string = open('sql/select_moboList.sql', 'r').read()
 269         result = db.execute(sql_string)
 270         moboList = result.fetchall()
 271
 272         #Fetch Case List
 273         sql_string = open('sql/select_caseList.sql', 'r').read()
 274         result = db.execute(sql_string)
 275         caseList = result.fetchall()
 276
 277         #Fetch PSU List
 278         sql_string = open('sql/select_psuList.sql', 'r').read()
 279         result = db.execute(sql_string)
 280         psuList = result.fetchall()
 281
 282         #Fetch RAM List
 283         sql_string = open('sql/select_ramList.sql', 'r').read()
 284         result = db.execute(sql_string)
 285         ramList = result.fetchall()
 286
 287         #Fetch GPU List
 288         sql_string = open('sql/select_gpuList.sql', 'r').read()
 289         result = db.execute(sql_string)
 290         gpuList = result.fetchall()
 291
 292         #Fetch SSD List
 293         sql_string = open('sql/select_ssdList.sql', 'r').read()
 294         result = db.execute(sql_string)
 295         ssdList = result.fetchall()
 296
 297         #Fetch HDD List
 298         sql_string = open('sql/select_hddList.sql', 'r').read()
 299         result = db.execute(sql_string)
 300         hddList = result.fetchall()
 301
 302         #Fetch CPU List
 303         sql_string = open('sql/select_cpuList.sql', 'r').read()
 304         result = db.execute(sql_string)
 305         cpuList = result.fetchall()
 306
 307         #Fetch CPU Cooling List
 308         sql_string = open('sql/select_cpuCoolList.sql', 'r').read()
 309         result = db.execute(sql_string)
 310         cpuCoolList = result.fetchall()
 311
 312         #Fetch Fan List
 313         sql_string = open('sql/select_fanList.sql', 'r').read()
 314         result = db.execute(sql_string)
 315         fanList = result.fetchall()
 316
 317         #Fetch LED Kit List
 318         sql_string = open('sql/select_ledkitList.sql', 'r').read()
 319         result = db.execute(sql_string)
 320         ledkitList = result.fetchall()
 321
 322         #Fetch OS List
 323         sql_string = open('sql/select_osList.sql', 'r').read()
 324         result = db.execute(sql_string)
 325         osList = result.fetchall()
 326
 327         return render_template('pcparts_addBuild.html', moboList=moboList,
 328                 caseList=caseList,
 329                 psuList=psuList,
 330                 ramList=ramList,
 331                 gpuList=gpuList,
 332                 ssdList=ssdList,
 333                 hddList=hddList,
 334                 cpuList=cpuList,
 335                 cpuCoolList=cpuCoolList,
 336                 fanList=fanList,
 337                 ledkitList=ledkitList,
 338                 osList=osList)
 339
 340 def get_pcBuildList():
 341         db = get_db()
 342         abc = db.execute('PRAGMA foreign_keys=ON')
 343         cur = db.execute('SELECT * FROM pcBuild')
 344         pcBuildList = cur.fetchall()
 345         return pcBuildList
 346
 347 #Submit POST - Add a New Build
 348 @app.route('/pcpart_add_build', methods=['GET', 'POST'])
 349 def add_build():
 350     if not session.get('logged_in'):
 351         abort(401)
 352     sql_string = open('sql/insert_build.sql', 'r').read()
 353     db = get_db()
 354     abc = db.execute('PRAGMA foreign_keys=ON')
 355     db.execute(sql_string, [request.form['pcBuild_name'],
 356         request.form['pcBuild_type'],
 357         request.form['pcBuild_notes'],
 358         request.form['pcBuild_avgPartAge'],
 359         request.form['pcBuild_mobo_id'],
 360         request.form['pcBuild_case_id'],
 361         request.form['pcBuild_ram_id'],
 362         request.form['pcBuild_gpu_id'],
 363         request.form['pcBuild_ssd_id'],
 364         request.form['pcBuild_hdd_id'],
 365         request.form['pcBuild_cpu_id'],
 366         request.form['pcBuild_psu_id'],
 367         request.form['pcBuild_cpuCool_id'],
 368         request.form['pcBuild_fan_id'],
 369         request.form['pcBuild_ledkit_id'],
 370         request.form['pcBuild_os_id'],
 371         request.form['pcBuild_colorScheme']])
 372     db.commit()
 373
 374     return redirect(url_for('pcparts_listBuilds'))
 375
 376
 377 """ ---------------- ---------------- Add Part ---------------- ----------------"""
 378 """ ---------------- Add Part - Generic ----------------"""
 379 #Display Form - Add a New Part
 380 @app.route('/pcparts_addPart.html', methods=['GET', 'POST'])
 381 def pcparts_addPart():
 382         pcBuildList = get_pcBuildList()
 383
 384         return render_template('pcparts_addPart.html', pcBuildList=pcBuildList)
 385
 386 #Submit POST - Add a New Part
 387 @app.route('/pcpart_add_part', methods=['GET', 'POST'])
 388 def add_part():
 389     if not session.get('logged_in'):
 390         abort(401)
 391
 392     sql_string = open('sql/insert_part.sql', 'r').read()
 393     request_string = ""
 394     db = get_db()
 395     abc = db.execute('PRAGMA foreign_keys=ON')
 396     db.execute(sql_string, [request.form['pcPart_type'],
 397         request.form['pcPart_name'],
 398         request.form['pcPart_modelNumber'],
 399         request.form['pcPart_price'],
 400         request.form['pcPart_desc'],
 401         request.form['pcPart_brand'],
 402         request.form['pcPart_condition'],
 403         request.form['pcPart_notes'],
 404         request.form['pcPart_age'],
 405         request.form['pcPart_pcBuild_id']])
 406     db.commit()
 407
 408     #return redirect(url_for('pcparts_addPart_ssd'))
 409     return redirect(url_for('display_addPart_details'))
 410
 411 """ ---------------- Add Part - Specific ----------------"""
 412
 413 #Display Form - Add Part Details - Generic
 414 @app.route('/display_addPart_details.html', methods=['GET', 'POST'])
 415 def display_addPart_details():
 416     db = get_db()
 417     abc = db.execute('PRAGMA foreign_keys=ON')
 418     cur = db.execute('SELECT max(pcPart_id) FROM pcPart')
 419     maxRowCount = cur.fetchall()
 420     currentPart = maxRowCount[0][0]
 421     print "currentPart"
 422     print currentPart
 423     print "currentPart"
 424     sql_string = "SELECT pcPart_type FROM pcPart WHERE pcPart_id = currentPart"
 425     print "sql_string"
 426     print sql_string
 427     print "sql_string"
 428     sql_string = sql_string.replace("currentPart", str(currentPart))
 429     get_partType = db.execute(sql_string)
 430     partTypeX = get_partType.fetchone()
 431     partType = partTypeX[0]
 432     print "partType"
 433     print partType
 434     print "partType"
 435     return render_template('display_addPart_details.html', currentPart=currentPart, partType=partType)
 436
 437 #
 438 #
 439 #    return render_template('display_addPart_details.html', currentPart=currentPart, partType=partType,
 440 #        moboList=dataList[0], caseList=dataList[1], psuList=dataList[2],
 441 #        ramList=dataList[3], gpuList=dataList[4], ssdList=dataList[5],
 442 #        hddList=dataList[6], cpuList=dataList[7], cpuCoolList=dataList[8],
 443 #        fanList=dataList[9], ledkitList=dataList[10], osList=dataList[11]
 444 #
 445 #
 446
 447
 448 #Submit POST - Add a New Part Details - Generic
 449 @app.route('/pcpart/add_part_details', methods=['POST'])
 450 def add_part_details():
 451         if not session.get('logged_in'):
 452                 abort(401)
 453         db = get_db()
 454         abc = db.execute('PRAGMA foreign_keys=ON')
 455         #SSD
 456         print "request.form['pc_part_id'] "
 457         print request.form['pc_part_id']
 458         print "request.form['pc_part_id'] "
 459         if request.form['part_type'] == "ssd":
 460                 sql_string = open('sql/insert_ssd.sql', 'r').read()
 461                 db.execute(sql_string,
 462                 [request.form['ssd_formFactor'],
 463                 request.form['ssd_size'],
 464                 request.form['ssd_interface'],
 465                 request.form['pc_part_id']])
 466                 db.commit()
 467                 flash('New part was added to database!')
 468                 return redirect(url_for('pcparts_list'))
 469         #RAM
 470         elif request.form['part_type'] == "ram":
 471                 sql_string = open('sql/insert_ram.sql', 'r').read()
 472                 db.execute(sql_string,
 473                 [request.form['ram_kitSize'],
 474                 request.form['ram_stickSize'],
 475                 request.form['ram_speed'],
 476                 request.form['ram_type'],
 477                 request.form['ram_casLatency'],
 478                 request.form['pc_part_id']])
 479                 db.commit()
 480                 flash('New part was added to database!')
 481                 return redirect(url_for('pcparts_list'))
 482         #HDD
 483         elif request.form['part_type'] == "hdd":
 484                 sql_string = open('sql/insert_hdd.sql', 'r').read()
 485                 db.execute(sql_string,
 486                 [request.form['hdd_formFactor'],
 487                 request.form['hdd_size'],
 488                 request.form['hdd_interface'],
 489                 request.form['hdd_cache'],
 490                 request.form['hdd_rpm'],
 491                 request.form['pc_part_id']])
 492                 db.commit()
 493                 flash('New part was added to database!')
 494                 return redirect(url_for('pcparts_list'))
 495         #CASE
 496         elif request.form['part_type'] == "case":
 497                 sql_string = open('sql/insert_case.sql', 'r').read()
 498                 db.execute(sql_string,
 499                 [request.form['case_formFactor'],
 500                 request.form['case_width'],
 501                 request.form['case_height'],
 502                 request.form['case_length'],
 503                 request.form['case_525bay'],
 504                 request.form['case_350bay'],
 505                 request.form['case_250bay'],
 506                 request.form['case_80fan'],
 507                 request.form['case_120fan'],
 508                 request.form['case_140fan'],
 509                 request.form['case_240fan'],
 510                 request.form['case_otherFan'],
 511                 request.form['case_fpSpk'],
 512                 request.form['case_fpMic'],
 513                 request.form['case_fpUSB3'],
 514                 request.form['case_fpUSB2'],
 515                 request.form['case_psuSlots'],
 516                 request.form['case_waterSlots'],
 517                 request.form['pc_part_id']])
 518                 db.commit()
 519                 flash('New part was added to database!')
 520                 return redirect(url_for('pcparts_list'))
 521         #GPU
 522         elif request.form['part_type'] == "gpu":
 523                 sql_string = open('sql/insert_gpu.sql', 'r').read()
 524                 db.execute(sql_string,
 525                 [request.form['gpu_vramType'],
 526                 request.form['gpu_vramSize'],
 527                 request.form['gpu_slotWidth'],
 528                 request.form['gpu_interface'],
 529                 request.form['gpu_6pin'],
 530                 request.form['gpu_8pin'],
 531                 request.form['gpu_clockSpeed'],
 532                 request.form['gpu_memClockSpeed'],
 533                 request.form['gpu_busBandwidth'],
 534                 request.form['gpu_crossfire'],
 535                 request.form['gpu_sli'],
 536                 request.form['pc_part_id']])
 537                 db.commit()
 538                 flash('New part was added to database!')
 539                 return redirect(url_for('pcparts_list'))
 540         #PSU
 541         elif request.form['part_type'] == "psu":
 542                 sql_string = open('sql/insert_psu.sql', 'r').read()
 543                 db.execute(sql_string,
 544                 [request.form['psu_watt'],
 545                 request.form['psu_effiency'],
 546                 request.form['psu_8pin'],
 547                 request.form['psu_6pin'],
 548                 request.form['psu_4pin'],
 549                 request.form['psu_molex'],
 550                 request.form['psu_sata'],
 551                 request.form['psu_floppy'],
 552                 request.form['pc_part_id']])
 553                 db.commit()
 554                 flash('New part was added to database!')
 555                 return redirect(url_for('pcparts_list'))
 556         #OS
 557         elif request.form['part_type'] == "os":
 558                 sql_string = open('sql/insert_os.sql', 'r').read()
 559                 db.execute(sql_string,
 560                 [request.form['os_type'],
 561                 request.form['os_bit'],
 562                 request.form['os_version'],
 563                 request.form['pc_part_id']])
 564                 db.commit()
 565                 flash('New part was added to database!')
 566                 return redirect(url_for('pcparts_list'))
 567         #CPU Cooler
 568         elif request.form['part_type'] == "cpuCool":
 569                 sql_string = open('sql/insert_cpuCool.sql', 'r').read()
 570                 db.execute(sql_string,
 571                 [request.form['cpuCool_type'],
 572                 request.form['cpuCool_socketList'],
 573                 request.form['cpuCool_fanCount'],
 574                 request.form['cpuCool_fanSize'],
 575                 request.form['pc_part_id']])
 576                 db.commit()
 577                 flash('New part was added to database!')
 578                 return redirect(url_for('pcparts_list'))
 579         #Motherboard
 580         elif request.form['part_type'] == "mobo":
 581                 sql_string = open('sql/insert_mobo.sql', 'r').read()
 582                 db.execute(sql_string,
 583                 [request.form['mobo_ramType'],
 584                 request.form['mobo_CPUsocket'],
 585                 request.form['mobo_dimmSlots'],
 586                 request.form['mobo_pciSlots'],
 587                 request.form['mobo_pcie16Slots'],
 588                 request.form['mobo_pcie8Slots'],
 589                 request.form['mobo_pcie4Slots'],
 590                 request.form['mobo_pcie1Slots'],
 591                 request.form['mobo_chipset'],
 592                 request.form['mobo_cpu4pin'],
 593                 request.form['mobo_cpu8pin'],
 594                 request.form['mobo_cpu6pin'],
 595                 request.form['pc_part_id']])
 596                 db.commit()
 597                 flash('New part was added to database!')
 598                 return redirect(url_for('pcparts_list'))
 599         #Fan
 600         elif request.form['part_type'] == "fan":
 601                 sql_string = open('sql/insert_fan.sql', 'r').read()
 602                 db.execute(sql_string,
 603                 [request.form['fan_size'],
 604                 request.form['fan_type'],
 605                 request.form['fan_color'],
 606                 request.form['pc_part_id']])
 607                 db.commit()
 608                 flash('New part was added to database!')
 609                 return redirect(url_for('pcparts_list'))
 610         #LED Kit
 611         elif request.form['part_type'] == "ledkit":
 612                 sql_string = open('sql/insert_ledkit.sql', 'r').read()
 613                 db.execute(sql_string,
 614                 [request.form['ledkit_color'],
 615                 request.form['ledkit_type'],
 616                 request.form['ledkit_notes'],
 617                 request.form['pc_part_id']])
 618                 db.commit()
 619                 flash('New part was added to database!')
 620                 return redirect(url_for('pcparts_list'))
 621         #Processor
 622         elif request.form['part_type'] == "cpu":
 623                 sql_string = open('sql/insert_cpu.sql', 'r').read()
 624                 db.execute(sql_string,
 625                 [request.form['cpu_socket'],
 626                 request.form['cpu_cores'],
 627                 request.form['cpu_threads'],
 628                 request.form['cpu_frequency'],
 629                 request.form['cpu_cache'],
 630                 request.form['cpu_wattage'],
 631                 request.form['pc_part_id']])
 632                 db.commit()
 633                 flash('New part was added to database!')
 634                 return redirect(url_for('pcparts_list'))
 635         else:
 636                 pass
 637
 638 #Display Form - Add Part Details - SSD
 639 @app.route('/pcparts_add_ssd.html', methods=['GET', 'POST'])
 640 def pcparts_addPart_ssd():
 641     currentTable = "pcPart"
 642     db = get_db()
 643     abc = db.execute('PRAGMA foreign_keys=ON')
 644     cur = db.execute('SELECT max(pcPart_id) FROM pcPart')
 645     maxRowCount = cur.fetchall()
 646     currentPart = maxRowCount[0][0]
 647     return render_template('pcparts_addPart_ssd.html', currentPart=currentPart)
 648
 649 #Submit POST - Add a New Part Details - SSD
 650 @app.route('/pcpart/add_ssd', methods=['POST'])
 651 def add_ssd():
 652     if not session.get('logged_in'):
 653         abort(401)
 654     sql_string = open('sql/insert_ssd.sql', 'r').read()
 655     db = get_db()
 656     abc = db.execute('PRAGMA foreign_keys=ON')
 657     db.execute(sql_string,
 658                  [request.form['ssd_formFactor'],
 659                  request.form['ssd_size'],
 660                  request.form['ssd_interface'],
 661                  request.form['pc_part_id']])
 662     db.commit()
 663     flash('New part was added to database!')
 664     return redirect(url_for('dashboard'))
 665
 666
 667 """ ---------------- ---------------- Update Part ---------------- ----------------"""
 668 #Display Form - Update a part
 669 @app.route('/pcparts/updatePart.html/', methods=['GET', 'POST'])
 670 def display_update_part():
 671         sql_string = open('sql/update_part.sql', 'r').read()
 672         #db = get_db()
 673         #db.execute('PRAGMA FOREIGN_KEYS=ON')
 674         selected_row = get_part(request.form['part_to_update'])
 675         #partId_to_update = request.form['part_to_update']
 676         #Display the page
 677         #   partId_to_update ==> current part id to update
 678         #   selected_row ==> the part's details
 679         return render_template('/pcparts/updatePart.html', selected_row=selected_row)
 680
 681
 682 #Submit POST - Update a Part
 683 @app.route('/pcparts/update_part', methods=['GET', 'POST'])
 684 def update_part():
 685         if not session.get('logged_in'):
 686                 abort(401)
 687         sql_string = open('sql/update_part.sql', 'r').read()
 688         db = get_db()
 689         abc = db.execute('PRAGMA foreign_keys=ON')
 690         db.execute(sql_string,[request.form['pcPart_type'], request.form['pcPart_name'], request.form['pcPart_modelNumber'], request.form['pcPart_price'], request.form['pcPart_desc'], request.form['pcPart_brand'], request.form['pcPart_condition'], request.form['pcPart_notes'], request.form['pcPart_age'], request.form['pcPart_id']])
 691         db.commit()
 692         flash('Part successfully updated!')
 693         return redirect(url_for('display_update_part_details', pcPartId=int(request.form['pcPart_id'])))
 694
 695
 696 #Display Form - Update a part's details
 697 @app.route('/pcparts/<int:pcPartId>/update_part_details.html', methods=['GET', 'POST'])
 698 def display_update_part_details(pcPartId):
 699         selected_row = get_part_details(pcPartId)
 700         #Display the page
 701         #   pcPartId ==> current part id
 702         #   selected_row ==> the part's details
 703         return render_template('/pcparts/updatePart_details.html', selected_row=selected_row)
 704
 705 #Submit POST - Update a Part's Details
 706 @app.route('/pcparts/update_part_details/', methods=['GET', 'POST'])
 707 def update_part_details():
 708         sql_string = open('sql/update_part_ssd.sql', 'r').read()
 709         #sql_string = sql_string.replace("pcPart_id", str(pcPartId))
 710         #part_table = "ssd"
 711         db = get_db()
 712         db.execute('PRAGMA FOREIGN_KEYS=ON')
 713         db.execute(sql_string,[ request.form['ssd_formFactor'],
 714                 request.form['ssd_size'],
 715                 request.form['ssd_interface'],
 716                 request.form['ssd_pcPart_id']])
 717         #Display the page
 718         #   pcPartId ==> current part id
 719         #   selected_row ==> the part's details
 720         db.commit()
 721         flash('Part details successfully updated!')
 722         #return render_template('pcparts_list.html')
 723         return pcparts_list()
 724
 725 """ ---------------- ---------------- Delete Part ---------------- ----------------"""
 726 @app.route('/delete_part', methods=['POST'])
 727 def delete_part():
 728         sql_string = open('sql/delete_part.sql', 'r').read()
 729         db = get_db()
 730         abc = db.execute('PRAGMA FOREIGN_KEYS=ON')
 731         db.execute(sql_string,[request.form['part_to_delete']])
 732         db.commit()
 733         flash('Part deleted from database!')
 734         return redirect(url_for('pcparts_list'))
 735
 736
 737 """ ---------------- ---------------- List PC Parts ---------------- ---------------- """
 738 @app.route('/pcparts/pcparts_ram')
 739 def pcparts_ram():
 740     return render_template('pcparts_ram.html')
 741
 742 @app.route('/pcparts/list_pcparts_ssd')
 743 def list_pcparts_ssd():
 744     return render_template('list_pcparts_ssd.html')
 745
 746 @app.route('/pcparts/pcparts_hdd')
 747 def pcparts_hdd():
 748     return render_template('pcparts_hdd.html')
 749
 750 @app.route('/pcparts/pcparts_case')
 751 def pcparts_case():
 752     return render_template('pcparts_case.html')
 753
 754 @app.route('/pcparts/pcparts_gpu')
 755 def pcparts_gpu():
 756     return render_template('pcparts_gpu.html')
 757
 758 @app.route('/pcparts/pcparts_psu')
 759 def pcparts_psu():
 760     return render_template('pcparts_psu.html')
 761
 762 @app.route('/pcparts/pcparts_os')
 763 def pcparts_os():
 764     return render_template('pcparts_os.html')
 765
 766 @app.route('/pcparts/pcparts_cpuCool')
 767 def pcparts_cpuCool():
 768     return render_template('pcparts_cpuCool.html')
 769
 770 @app.route('/pcparts/pcparts_mobo')
 771 def pcparts_mobo():
 772     return render_template('pcparts_mobo.html')
 773
 774 @app.route('/pcparts/pcparts_fan')
 775 def pcparts_fan():
 776     return render_template('pcparts_fan.html')
 777
 778 @app.route('/pcparts/pcparts_ledkit')
 779 def pcparts_ledkit():
 780     return render_template('pcparts_ledkit.html')
 781
 782 @app.route('/pcparts/pcparts_cpu')
 783 def pcparts_cpu():
 784     return render_template('pcparts_cpu.html')
 785
 786 #def pcparts_ssd():
 787     #print "OOOOOOOOOOOOOOOOOOOOOO"
 788     #print selected_row
 789     #print "OOOOOOOOOOOOOOOOOOOOOO"
 790     #print "PC PART ID: " + str(pcPartId) + " ---"
 791     #sql_string = open('select_ssd.sql', 'r').read()
 792     #sql_string = sql_string.replace("pcPart_id", str(pcPartId))
 793     #db = get_db()
 794     #cur = db.execute(sql_string, [pcPartId])
 795     #items = cur.fetchall()
 796
 797
 798 """ ---------------- ---------------- List Items ---------------- ---------------- """
 799 #Display Data - List All Items
 800 @app.route('/item_list')
 801 def item_list():
 802     sql_string = open('sql/select_all_items.sql', 'r').read()
 803     db = get_db()
 804     cur = db.execute(sql_string)
 805     items = cur.fetchall()
 806     return render_template('item_list.html', items=items)
 807
 808 #Display Form - Add Item
 809 @app.route('/add_item')
 810 def add_item():
 811     return render_template('add_item.html')
 812
 813 #Submit POST - Add Item
 814 @app.route('/add', methods=['POST'])
 815 def submit_item():
 816     if not session.get('logged_in'):
 817         abort(401)
 818     db = get_db()
 819     db.execute('insert into item (item_name, item_subtitle, \
 820                 item_desc, item_category, item_condition, item_conditionDesc, item_cost) \
 821                 values (?, ?, ?, ?, ?, ?, ?)',
 822                  [request.form['item_name'],
 823                  request.form['item_subtitle'],
 824                  request.form['item_desc'],
 825                  request.form['item_category'],
 826                  request.form['item_condition'],
 827                  request.form['item_conditionDesc'],
 828                  request.form['item_cost']])
 829     db.commit()
 830     flash('New item was added to database!')
 831     return redirect(url_for('item_list'))
 832
 833
 834
 835