예제 #1
0
 def checkUserExist(email):
     cursor, conn = flaskConfig.connect_db()
     cursor.execute("SELECT * FROM user WHERE user_email = (?)", (email,))
     fetchall = cursor.fetchall()
     conn.close()
     gc.collect()
     return fetchall
예제 #2
0
def livesearch(searchQuery):
    cursor, conn = flaskConfig.connect_db()
    # cursor.execute('SELECT * FROM part WHERE part_name LIKE (?)', ('%'+searchQuery+'%',))
    cursor.execute('CREATE VIRTUAL TABLE IF NOT EXISTS virt_part USING fts4(part_id,part_name,part_manufacturer,part_model_number,part_place_of_origin,part_description,part_internal_or_external,part_type,part_med_res_img,part_thumb_img,part_view_count)')
    cursor.execute("INSERT INTO virt_part(part_id,part_name,part_manufacturer,part_model_number,part_place_of_origin,part_description,part_internal_or_external,part_type,part_med_res_img,part_thumb_img,part_view_count) SELECT part_id,part_name,part_manufacturer,part_model_number,part_place_of_origin,part_description,part_internal_or_external,part_type,part_med_res_img,part_thumb_img,part_view_count FROM part")
    cursor.execute('SELECT * FROM virt_part WHERE part_name MATCH (?)',(searchQuery,))
    fetchall = cursor.fetchall()
    cursor.execute('DROP TABLE IF EXISTS virt_part')

    # -? This limits results to 50 items.
    fetchall = fetchall[:51]

    searchResults = {}

    for i in fetchall:
        dictName = str(i[0])
        iDictionary = {dictName:
                            {'part_id':i[0],
                            'part_name':i[1],
                            'part_manufacturer':i[2],
                            'part_model_number':i[3],
                            'part_place_of_origin':i[4],
                            'part_description':i[5][:750],
                            'part_internal_or_external':i[6],
                            'part_type':i[7],
                            'part_med_res_img':i[8],
                            'part_thumb_img':i[9],
                            'part_view_count':i[10]}
                       }
        searchResults.update(iDictionary)

    return make_response(jsonify({'200': 'OK','searchResults':searchResults}), 200)
예제 #3
0
def apiPartRetailers(partId):
    cursor, conn = flaskConfig.connect_db()
    cursor.execute("SELECT * FROM retailer WHERE part_id = (?)", (partId,))
    fetchall = cursor.fetchall()
    conn.close()
    gc.collect()

    if len(fetchall) > 0:

        fetchall = fetchall[0]

        # -? Convert tuple into list.
        fetch_list = list(fetchall)

        # -? Split list into featured and also lists.
        featured = fetch_list[2]
        also_list = fetch_list[3:]

        # -? removes all None from also_list
        also_list = [i for i in also_list if i is not None]

        # -? Shuffles order of also_list
        shuffle(also_list)

        return make_response(jsonify(featured=featured,also_list=also_list), 200)
    else:
        return make_response(jsonify({'302': 'FOUND', 'details':'no retailers found', 'tag':'noRetailers'}), 302)
예제 #4
0
 def nextPartSeq():
     # This will return value of the next sequence number for part table.
     cursor, conn = flaskConfig.connect_db()
     cursor.execute("SELECT * from sqlite_sequence WHERE name = 'part'")
     fetchall = cursor.fetchall()
     conn.close()
     gc.collect()
     nextPartId = str(fetchall[0][1] + 1)
     return nextPartId
예제 #5
0
 def processDisapprove(self, pendingEditId, userId, vote):
     cursor, conn = flaskConfig.connect_db()
     # This will add the vote to the pendingedit table.
     cursor.execute("UPDATE pendingedit SET downvote = downvote + 1 WHERE pendingedit_id = (?)",(pendingEditId,))
     conn.commit()
     # This will now add the user to pendinvvote table so they can't vote twice.
     cursor.execute("INSERT INTO pendingvote (pendingvote_id, user_id, pendingedit_id, vote) VALUES (?,?,?,?)", (None, userId, pendingEditId, vote))
     conn.commit()
     conn.close()
     gc.collect()
예제 #6
0
 def voteFetch(self, userId, pendingEditId):
     cursor, conn = flaskConfig.connect_db()
     cursor.execute("""SELECT pendingvote.pendingvote_id, pendingvote.user_id, pendingvote.pendingedit_id, pendingvote.vote from pendingvote
                       INNER JOIN pendingedit
                       ON pendingedit.pendingedit_id = pendingvote.pendingedit_id
                       WHERE pendingvote.user_id = (?) AND pendingvote.pendingedit_id = (?)""", (userId, pendingEditId))
     fetchall = cursor.fetchall()
     conn.close()
     gc.collect()
     return fetchall
예제 #7
0
 def processDownvote(self, currentPartId, compatibleToPartId, userId, compatibilityId):
     cursor, conn = flaskConfig.connect_db()
     # This will add the downvote to the db.
     cursor.execute("UPDATE compatibility SET not_compatible_score = not_compatible_score + 1 WHERE part_id = (?) AND compatible_to_part_id = (?)", (currentPartId, compatibleToPartId,))
     conn.commit()
     # This will now add the user to vote table so they can't vote twice.
     cursor.execute("INSERT INTO vote (vote_id, user_id, compatibility_id, vote) VALUES (?,?,?,?)", (None, userId, compatibilityId, 'downvote',))
     conn.commit()
     conn.close()
     gc.collect()
예제 #8
0
 def voteFetch(self, userId, compatibilityId):
     cursor, conn = flaskConfig.connect_db()
     cursor.execute("""SELECT vote.vote_id, vote.user_id, vote.compatibility_id, vote.vote from vote
                       INNER JOIN compatibility
                       ON compatibility.compatibility_id = vote.compatibility_id
                       WHERE vote.user_id = (?) AND vote.compatibility_id = (?)""", (userId,compatibilityId,))
     fetchall = cursor.fetchall()
     conn.close()
     gc.collect()
     return fetchall
예제 #9
0
 def checkExist():
     cursor, conn = flaskConfig.connect_db()
     cursor.execute("""SELECT part_id, compatible_to_part_id FROM compatibility
                       WHERE part_id == (?) AND compatible_to_part_id == (?)""" , (partId, post['compatible_to_part_id']))
     fetchall = cursor.fetchall()
     if len(fetchall) > 0:
         # yup, this combo already exists
         return True
     else:
         # nope, this is a unique entry
         return False
예제 #10
0
    def findallCompIncomp(self, partid):
        cursor, conn = flaskConfig.connect_db()
        cursor.execute("""SELECT compatibility.part_id, compatibility.compatible_to_part_id
                          FROM compatibility WHERE compatibility.part_id = (?)""", (partid,))
        compatiblePairs = cursor.fetchall()

        allCompatibleQuery = []

        for i in compatiblePairs:
            compatible_to_part_id = i[1]
            cursor.execute("""SELECT *
                               FROM part INNER JOIN compatibility ON part.part_id = compatibility.compatible_to_part_id
                               WHERE compatibility.compatible_to_part_id = (?) AND compatibility.part_id = (?)""", (compatible_to_part_id, partid,))
            fetch = cursor.fetchall()
            allCompatibleQuery.append(fetch[0])
        return allCompatibleQuery
예제 #11
0
    def selectedPartInfo(self, partId):
        cursor, conn = flaskConfig.connect_db()
        cursor.execute("SELECT * FROM part WHERE part_id = (?)", (partId,))
        curentPartFetchall = cursor.fetchall()
        curentPartTuple = curentPartFetchall[0]
        conn.close()
        gc.collect()

        currentPartDict = {'part_id':curentPartTuple[0],
                        'part_name':curentPartTuple[1],
                        'part_manufacturer':curentPartTuple[2],
                        'part_model_number':curentPartTuple[3],
                        'part_place_of_origin':curentPartTuple[4],
                        'part_estimated_price':curentPartTuple[5],
                        'part_description':curentPartTuple[6],
                        'part_internal_or_external':curentPartTuple[7],
                        'part_type':curentPartTuple[8],
                        'part_full_res_img':curentPartTuple[9],
                        'part_med_res_img':curentPartTuple[10],
                        'part_thumb_img':curentPartTuple[11],
                        'part_added_to_db':curentPartTuple[12],
                        'part_view_count':curentPartTuple[13]}
        return currentPartDict
예제 #12
0
def apiRegister():
    # Step 1: Initialize data for processing.
    formData = request.get_json()
    firstName = formData['firstName']
    lastName = formData['lastName']
    email = str(formData['email'])
    password = sha256_crypt.encrypt((str(formData['password'])))

    # Step 2: Verify POST method and search DB for same email to avoid duplicate accounts.
    if request.method == 'POST':
        cursor, conn = flaskConfig.connect_db()
        cursor.execute("SELECT * FROM user WHERE user_email = (?)", (email,))
        fetchall = cursor.fetchall()

        # Step 3: If exist, return 302. If not, add formData to DB and create new sessions.
        if len(fetchall) > 0:
            # This email already exists in the database.
            return make_response(jsonify({'302': 'FOUND', 'details':'This email already exists in the database.', 'tag':'emailExists'}), 302)
        else:
            # This email does not already exist in database. Now creating new user account.
            cursor.execute("INSERT INTO user VALUES (?,?,?,?,?)", (None, email, password, firstName, lastName,))
            conn.commit()
            cursor.execute("SELECT * FROM user WHERE user_email = ('%s')" % (email))
            fetchall = cursor.fetchall()
            newUserId = fetchall[0][0]
            conn.close()
            gc.collect()

            session['logged_in'] = True
            session['user_id'] = newUserId
            session['email'] = email
            session['user_firstname'] = firstName
            session['user_lastname'] = lastName

            return make_response(jsonify({'200': 'OK','details':'New user account successfully created!','email':email,'tag':'register'}), 200)

        return make_response(jsonify({'200': 'OK'}), 200)
예제 #13
0
def apiSuggestEdit(partId,inQuestion):

    # -- GET REQUESTS
    if request.method == 'GET':

        # -? Will find all rows that match the requested partId and category in question.
        cursor, conn = flaskConfig.connect_db()
        cursor.execute("SELECT * FROM pendingedit WHERE part_id = (?) AND inquestion = (?)", (partId, inQuestion,))
        pendingFetch = cursor.fetchall()
        gc.collect()

        dict = {}

        for i in pendingFetch:
            dictName = str(i[0])
            userId = i[2]

            # -? Retrieves the user name for each row in pendingFetch.
            cursor, conn = flaskConfig.connect_db()
            cursor.execute("SELECT user_firstname, user_lastname FROM user WHERE user_id = (?) ", (userId,))
            fetchall = cursor.fetchall()
            userfetch = fetchall
            userfetch = userfetch[0]
            gc.collect()

            iDict = {dictName:{'pendingId':i[0],
                               'partId':i[1],
                               'userId':userId,
                               'userName':userfetch[0] + ' ' + userfetch[1][:1]+'.',
                               'inQuestion':i[3],
                               'suggestion':i[4],
                               'reasoning':i[5],
                               'downvote':i[6],
                               'upvote':i[7],
                               'timestamp':i[8]
                               }}
            dict.update(iDict)

        return make_response(jsonify(apiSuggestEdit = dict))

    # -- POST REQUESTS
    elif request.method == 'POST':
        post = request.get_json()
        print post

        #HANDLE VOTE REQUEST
        try:
            if post['vote'] == 'approve' or 'disapprove':

                # Step 1: Check if user is logged in already.
                if session.get('logged_in') == None:
                    return make_response(jsonify({'302': 'FOUND', 'details':'login required','tag':'pendingvote'}),302)

                # Step 2: Initialize data for vote processing
                userId = session['user_id']
                pendingEditId = post['pendingEditId']
                vote = post['vote']

                # Step 3: Evaluates DB query results to see if user has already voted on this item.
                voteFetch = processVote().voteFetch(userId,pendingEditId)
                if len(voteFetch) > 0:
                    # Match found. Responding with JSON error.
                    return make_response(jsonify({'302':'FOUND','details':'user already voted for this suggested edit','tag':'alreadyvoted'}),302)
                else:
                    if post['vote'] == 'approve':
                        # No match found. Now writing approval to database.
                        processVote().processApprove(pendingEditId, userId, vote)
                        return make_response(jsonify({'200': 'OK', 'details':'approval vote to database success!', 'tag':'approval success'}), 200)
                    elif post['vote'] == 'disapprove':
                        # No match found. Now writing disapproval to database.
                        processVote().processDisapprove(pendingEditId, userId, vote)
                        return make_response(jsonify({'200': 'OK', 'details':'disapproval to database success!', 'tag':'disapproval success'}), 200)
        except:
            pass


        try:
            inQuestionTags = ['partName','manufacturer','modelNumber','placeOfOrigin','partType','internalOrExternal','description','forSaleAt']
            if post['editCurrentTag'] in inQuestionTags:
                inQuestion = post['editCurrentTag']
                edit = post['formData']['edit']
                reasoning = post['formData']['reasoning']
                userId = post['userId']
                partId = post['partId']

                # Adds edit suggestion to database
                cursor, conn = flaskConfig.connect_db()
                cursor.execute('INSERT INTO pendingedit VALUES (?,?,?,?,?,?,?,?,?)',(None, partId, userId, inQuestion, edit, reasoning, 0, 0, datetime.datetime.now()))
                conn.commit()
                conn.close()
                gc.collect()
                return make_response(jsonify({'200': 'OK', 'details':'edit suggestion successfully added to database!', 'tag':'editSuggestSuccess'}))
        except:
            pass


    return make_response(jsonify({'200': 'OK', 'details':'succesfully connected', 'tag':'test'}), 200)
예제 #14
0
def apiAddToDb(partId, compmode):
    # Step 1: Obtain form data for processing.
    formData = request.form
    file = request.files["file"]

    def nextPartSeq():
        # This will return value of the next sequence number for part table.
        cursor, conn = flaskConfig.connect_db()
        cursor.execute("SELECT * from sqlite_sequence WHERE name = 'part'")
        fetchall = cursor.fetchall()
        conn.close()
        gc.collect()
        nextPartId = str(fetchall[0][1] + 1)
        return nextPartId

    # Step 2: Find what is the next seq number for part table.
    nextPartId = nextPartSeq()

    # This will check to verify if file name is allowed within ALLOWED_EXTENSIONS.
    def allowed_file(filename):
        return "." in filename and filename.rsplit(".", 1)[1] in ALLOWED_EXTENSIONS

    # This will rename the uploaded file to be suited for usage in /images/part-images/..
    def rename_file(filename):
        partName = formData["partName"].replace(" ", "-").lower()[0:18]
        filename = str(nextPartId) + "-" + "1" + "-" + str(partName)
        return filename

    # # This will remove quotes and single quotes from partDescription.
    # def renamePartDesc(string):
    #     string = string.replace('"'," ")
    #     string = string.replace("'"," ")
    #     return string

    # partDescription = renamePartDesc(formData['partDescription'])

    if file and allowed_file(file.filename):
        # DEBUG: code does not like part names that contain special characters such as '/' or '.'
        filename = secure_filename(file.filename)
        filename = rename_file(filename)
        file.save(os.path.join(UPLOAD_FOLDER, filename))

        saved_location = os.path.join(UPLOAD_FOLDER, filename)
        work_file = Image.open(saved_location)

        full_res = work_file.copy()
        med = work_file.copy()
        thumb = work_file.copy()
        imgUrlDict = {"full_res_url": "", "med_res_url": "", "thumb_res_url": ""}

        def make_full_res():
            new_dimensions = (900, 900)
            full_res.thumbnail(new_dimensions)
            full_res.save(UPLOAD_FOLDER + "full-res/%s" % (filename + "-full-res") + ".jpg", "JPEG")
            full_res_name = filename + "-full-res" + ".jpg"
            full_res_url = "images/part-images/full-res/" + full_res_name
            imgUrlDict["full_res_url"] = full_res_url

        def make_med():
            new_dimensions = (400, 400)
            med.thumbnail(new_dimensions)
            med.save(UPLOAD_FOLDER + "med-res/%s" % (filename + "-med") + ".jpg", "JPEG")
            med_name = filename + "-med" + ".jpg"
            med_res_url = "images/part-images/med-res/" + med_name
            imgUrlDict["med_res_url"] = med_res_url

        def make_thumb():
            new_dimensions = (150, 150)
            thumb.thumbnail(new_dimensions)
            thumb.save(UPLOAD_FOLDER + "thumb/%s" % (filename + "-thumb") + ".jpg", "JPEG")
            thumb_name = filename + "-thumb" + ".jpg"
            thumb_res_url = "images/part-images/thumb/" + thumb_name
            imgUrlDict["thumb_res_url"] = thumb_res_url

        make_full_res()
        make_med()
        make_thumb()
        # This will save new submitted part to part table.
        cursor, conn = flaskConfig.connect_db()
        cursor.execute(
            """INSERT INTO part
                          VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
                          """,
            (
                None,
                formData["partName"],
                formData["partManufacturer"],
                formData["partModelNumber"],
                formData["placeOfOrigin"],
                None,
                formData["partDescription"],
                formData["internalOrExternal"],
                formData["partType"],
                imgUrlDict["full_res_url"],
                imgUrlDict["med_res_url"],
                imgUrlDict["thumb_res_url"],
                None,
                None,
            ),
        )
        conn.commit()
        conn.close()
        gc.collect()

        # This will add new submitted part to compatibility table & rank compatibility score according to URL param.
        if partId != "new" and compmode != "new":
            compatible_score = 0
            not_compatible_score = 0

            if compmode == "green":
                compatible_score = 1
            elif compmode == "red":
                not_compatible_score = 1

            cursor, conn = flaskConfig.connect_db()
            cursor.execute(
                "INSERT INTO compatibility VALUES (?,?,?,?,?)",
                (None, partId, nextPartId, compatible_score, not_compatible_score),
            )
            conn.commit()
            conn.close()
            gc.collect()

        return make_response(
            jsonify(
                {"200": "OK", "details": "Part added to database success!", "nextPartId": nextPartId, "tag": "addtodb"}
            ),
            200,
        )
예제 #15
0
def apiWhyMod(compId,whymod):

    # -- GET REQUESTS
    if request.method == 'GET':
        if whymod == 'all':
            cursor, conn = flaskConfig.connect_db()
            cursor.execute("SELECT * FROM whymod WHERE compatibility_id = ('%s')" % (compId))
            fetchall = cursor.fetchall()
            fetchall = fetchall
            conn.close()
            gc.collect()

            if len(fetchall) < 1:
                return make_response(jsonify({'302': 'FOUND', 'details':'no results found','tag':'allNoRes'}), 302)

            dict = {}

            for i in fetchall:
                dictName = str(i[0])
                iDict = {dictName:{'whymod_id':i[0],
                                   'compatibility_id':i[1],
                                   'user_id':i[2],
                                   'user_firstname':i[3],
                                   'user_lastname':i[4][:1]+'.',
                                   'whyormod':i[5],
                                   'title':i[6],
                                   'desc':i[7],
                                   'helpful':i[8],
                                   'timestamp':i[9][0:10]}}
                dict.update(iDict)
            return make_response(jsonify(whymod=dict), 200)

        elif whymod == 'why':
            cursor, conn = flaskConfig.connect_db()
            cursor.execute("SELECT * FROM whymod WHERE compatibility_id = ('%s') AND whyormod = ('%s')" % (compId,whymod))
            fetchall = cursor.fetchall()
            fetchall = fetchall
            conn.close()
            gc.collect()

            if len(fetchall) < 1:
                return make_response(jsonify({'302': 'FOUND', 'details':'no results found','tag':'whyNoResults'}), 302)

            dict = {}

            for i in fetchall:
                dictName = str(i[0])
                iDict = {dictName:{'whymod_id':i[0],
                                   'compatibility_id':i[1],
                                   'user_id':i[2],
                                   'user_firstname':i[3],
                                   'user_lastname':i[4][:1]+'.',
                                   'whyormod':i[5],
                                   'title':i[6],
                                   'desc':i[7],
                                   'helpful':i[8],
                                   'timestamp':i[9][0:10]}}
                dict.update(iDict)
            return make_response(jsonify(whymod=dict), 200)

        elif whymod == 'mod':
            cursor, conn = flaskConfig.connect_db()
            cursor.execute("SELECT * FROM whymod WHERE compatibility_id = ('%s') AND whyormod = ('%s')" % (compId,whymod))
            fetchall = cursor.fetchall()
            fetchall = fetchall
            conn.close()
            gc.collect()

            if len(fetchall) < 1:
                return make_response(jsonify({'302': 'FOUND', 'details':'no results found','tag':'modNoRes'}), 302)

            dict = {}

            for i in fetchall:
                dictName = str(i[0])
                iDict = {dictName:{'whymod_id':i[0],
                                   'compatibility_id':i[1],
                                   'user_id':i[2],
                                   'user_firstname':i[3],
                                   'user_lastname':i[4][:1]+'.',
                                   'whyormod':i[5],
                                   'title':i[6],
                                   'desc':i[7],
                                   'helpful':i[8],
                                   'timestamp':i[9][0:10]}}
                dict.update(iDict)
            return make_response(jsonify(whymod=dict), 200)

    # -- POST REQUESTS
    elif request.method == 'POST':

        # HANDLE POST REQUESTS TO 'MOD'
        if whymod == 'mod':
            post = request.get_json()
            print post
            cursor, conn = flaskConfig.connect_db()
            # refer to this http://stackoverflow.com/questions/3952543/python-and-sqlite-escape-input
            cursor.execute('INSERT INTO whymod VALUES (?,?,?,?,?,?,?,?,?,?)', (None, post['compatibility_id'], post['user_id'], post['user_firstname'],post['user_lastname'],'mod',post['title'],post['desc'],0,datetime.datetime.now()))
            conn.commit()
            conn.close()
            gc.collect()
            return make_response(jsonify({'200': 'OK', 'details':'mod successfully added to database!', 'tag':'shareModSuccess'}), 200)

        # HANDLE POST REQUESTS TO 'WHY'
        elif whymod == 'why':
            post = request.get_json()
            print post

            # This will add the new why post to database
            cursor, conn = flaskConfig.connect_db()
            # refer to this http://stackoverflow.com/questions/3952543/python-and-sqlite-escape-input
            cursor.execute('INSERT INTO whymod VALUES (?,?,?,?,?,?,?,?,?,?)', (None, post['compatibility_id'], post['user_id'], post['user_firstname'],post['user_lastname'],'why',post['title'],post['desc'],0,datetime.datetime.now()))
            conn.commit()
            conn.close()
            gc.collect()
            return make_response(jsonify({'200': 'OK', 'details':'why successfully added to database!', 'tag':'shareWhySuccess'}), 200)

        # HANDLE POST REQUESTS TO 'VOTE'
        elif whymod == 'vote':
            post = request.get_json()

            # Step 1: Check to see if this user has already voted on this particular whymod_id.
            cursor, conn = flaskConfig.connect_db()
            cursor.execute('SELECT * FROM whymodvote WHERE user_id = (?) AND whymod_id = (?)',(post['user_id'],post['whymod_id']))
            fetchall = cursor.fetchall()
            print fetchall

            # Returns 302 error if user has already voted on this particular whymod_id.
            if len(fetchall) > 0:
                return make_response(jsonify({'302': 'FOUND', 'details':'user already voted for this whymod_id', 'tag':'alreadyvoted'}), 302)

            # Step 2: Else writes new vote to database and returns success JSON.
            else:
                print 'user has not voted on this particular whymod_id'
                # increment helpful in whymod by one point
                cursor, conn = flaskConfig.connect_db()
                cursor.execute('UPDATE whymod SET helpful = helpful + 1 WHERE whymod_id = (?)',(post['whymod_id'],))
                conn.commit()
                # add user to whymodvote to prevent multiple votes.
                cursor.execute('INSERT INTO whymodvote VALUES (?,?,?)', (None,post['user_id'],post['whymod_id'],))
                conn.commit()
                conn.close()
                gc.collect()
                return make_response(jsonify({'200': 'OK', 'details':'whymod vote successfully added to database!', 'tag':'WhyModVoteSuccess'}), 200)
예제 #16
0
def apiAddPart(partId, compmode):
    if session.get('user_id') == None:
            return make_response(jsonify({'302': 'FOUND', 'details':'login required', 'tag':'addpart'}), 302)

    # -- GET REQUESTS
    if request.method == 'GET':

        searchQuery = request.args.get('search')

        cursor, conn = flaskConfig.connect_db()
        cursor.execute("SELECT * FROM part WHERE part_name LIKE ('%s')" % ('%'+searchQuery+'%'))
        fetchall = cursor.fetchall()

        searchResults = {}

        for i in fetchall:
            dictName = str(i[0])
            iDictionary = {dictName:
                                {'part_id':i[0],
                                 'part_name':i[1],
                                 'part_manufacturer':i[2],
                                 'part_model_number':i[3],
                                 'part_place_of_origin':i[4],
                                 'part_description':i[6],
                                 'part_internal_or_external':i[7],
                                 'part_type':i[8],
                                 'part_med_res_img':i[10],
                                 'part_thumb_img':i[11],
                                 'alreadyAssociated':None}
                           }
            searchResults.update(iDictionary)
        return jsonify(searchResults = searchResults)

    # -- POST REQUESTS
    elif request.method == 'POST':

        # Step 1: Initialize data for add part processing
        post = request.get_json()
        compatible_score = 0;
        not_compatible_score = 0;

        if compmode == 'green':
            compatible_score = 1
        elif compmode == 'red':
            not_compatible_score = 1

        def checkExist():
            cursor, conn = flaskConfig.connect_db()
            cursor.execute("""SELECT part_id, compatible_to_part_id FROM compatibility
                              WHERE part_id == (?) AND compatible_to_part_id == (?)""" , (partId, post['compatible_to_part_id']))
            fetchall = cursor.fetchall()
            if len(fetchall) > 0:
                # yup, this combo already exists
                return True
            else:
                # nope, this is a unique entry
                return False

        # Step 2: will write to DB if this compatibility combination does not already exist.
        if checkExist() == False:
            cursor, conn = flaskConfig.connect_db()
            cursor.execute('INSERT INTO compatibility VALUES (?,?,?,?,?)', (None, partId, post['compatible_to_part_id'], compatible_score, not_compatible_score ))
            conn.commit()
            conn.close()
            gc.collect()
            return make_response(jsonify({'200': 'OK', 'details':'Part successfully added to compatibility list', 'tag':'addpart'}), 200)
        else:
            return make_response(jsonify({'302': 'FOUND', 'details':'Write to DB declined. These two parts are already associated.', 'tag':'addpart'}), 302)