Example #1
0
def form(key):
    # Highest Role
    role = None
    if auth_check("security_officer"):
        role = "security_officer"
    elif auth_check("recruiter"):
        role = "recruiter"

    # Recruitment Info
    try:
        if request.form.get("action") == "submit":
            insert = {}
            for question_key, value in request.form.items():
                if question_key not in ["action", "submitted"]:
                    key_split = question_key.split("_")
                    if key_split[1] == "bool":
                        insert[key_split[0]] = value == "True"
                    else:
                        insert[key_split[0]] = value.strip()
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)}, {
                    "$set": {
                        "questions": insert,
                        "submitted": True,
                        "status": "Submitted"
                    }
                },
                return_document=ReturnDocument.AFTER)
            # Discord Integration
            g.redis.publish(
                'titdev-recruitment',
                "@everyone: {0} has submitted a recruitment form: {1}".format(
                    session["CharacterName"],
                    url_for("recruitment.form", key=key, _external=True)))

            if request.form.get("submitted") == "True":
                flash("Application edited", "success")
            else:
                flash("Application submitted", "success")
        elif request.form.get("action") in [
                "process", "interview", "accept", "reject", "release"
        ] and role == "security_officer":
            status_strings = {
                "process":
                "Processing",
                "interview":
                "Interview Required",
                "accept":
                "Accepted",
                "reject":
                "Rejected",
                "release":
                "Submitted"
                if request.form.get("submitted") == "True" else "Not Submitted"
            }
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)}, {
                    "$set": {
                        "status": status_strings[request.form.get("action")],
                        "reason": request.form.get("reason")
                    }
                },
                return_document=ReturnDocument.AFTER)
            # Discord Integration
            if request.form.get("action") not in ["process", "release"]:
                g.redis.publish(
                    'titdev-recruitment',
                    "@everyone: {0} has marked a form as {2}: {1}".format(
                        session["CharacterName"],
                        url_for("recruitment.form", key=key, _external=True),
                        status_strings[request.form.get("action")]))
        elif request.form.get("action") == "flag" and role:
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)}, {
                    "$set": {
                        "met_recruiter":
                        request.form.get("met_recruiter") == "False"
                    }
                },
                return_document=ReturnDocument.AFTER)
        elif request.form.get(
                "action") == "delete" and role == "security_officer":
            if request.form.get("confirm") == key:
                g.mongo.db.applications.delete_one({"_id": ObjectId(key)})
                flash("Application Deleted", "success")
                return redirect(url_for("recruitment.home"))
            else:
                app_info = g.mongo.db.applications.find_one(
                    {"_id": ObjectId(key)})
                flash("Key doesn't match", "error")
        elif request.form.get(
                "action") == "officer_edit" and role == "security_officer":
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {"$set": {
                    "officer_notes": request.form.get("officer_edit")
                }},
                return_document=ReturnDocument.AFTER)
            flash("Officer Notes Edited", "success")
        elif request.form.get("action") == "recruiter_edit" and role:
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)}, {
                    "$set": {
                        "recruiter_notes": request.form.get("recruiter_edit")
                    }
                },
                return_document=ReturnDocument.AFTER)
            flash("Recruiter Notes Edited", "success")
        elif request.form.get("action") == "recruiter":
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {"$set": {
                    "recruiter": request.form.get("recruiter")
                }},
                return_document=ReturnDocument.AFTER)
            flash("Recruiter Changed", "success")
        else:
            app_info = g.mongo.db.applications.find_one({"_id": ObjectId(key)})
    except bson.errors.InvalidId:
        flash("Invalid Key", "error")
        return redirect(url_for("recruitment.home"))

    if app_info:
        key_owner = app_info.get("owner")
        if not key_owner:
            g.mongo.db.applications.update_one({"_id": ObjectId(key)}, {
                "$set": {
                    "owner": session["CharacterOwnerHash"],
                    "character_name": session["CharacterName"]
                }
            })
            key_owner = session["CharacterOwnerHash"]
        if key_owner == session["CharacterOwnerHash"] or role:
            app_key = key.strip()
            app_status = app_info.get("status", "Not submitted")
            app_reason = app_info.get("reason")
        else:
            flash("Key Already Used", "error")
            return redirect(url_for("recruitment.home"))
    else:
        flash("Key Not Found", "error")
        return redirect(url_for("recruitment.home"))

    # APIs
    error_list = []
    if request.method == "POST":
        if request.form.get("action") == "add":
            error_list = caches.api_keys(
                [(request.form.get("key_id"), request.form.get("vcode"))],
                dashboard_id=key_owner)
        elif request.form.get("action") == "remove":
            g.mongo.db.api_keys.update_one({"_id": key_owner}, {
                "$pull": {
                    "keys": {
                        "key_id": int(request.form.get("key_id"))
                    }
                }
            })
            g.mongo.db.api_keys.update_one({"_id": key_owner}, {
                "$push": {
                    "old_keys": {
                        "key_id": int(request.form.get("key_id")),
                        "vcode": request.form.get("vcode"),
                        "delete_time": int(time.time())
                    }
                }
            })
        elif request.form.get(
                "action") == "remove_old" and role == "security_officer":
            g.mongo.db.api_keys.update_one({"_id": key_owner}, {
                "$pull": {
                    "old_keys": {
                        "key_id": int(request.form.get("key_id"))
                    }
                }
            })

    associated_keys = []
    associated_old_keys = []
    # List of characters
    db_key_doc = g.mongo.db.api_keys.find_one({"_id": key_owner})
    if db_key_doc:
        for key in db_key_doc["keys"]:
            associated_keys.append([
                key["character_id"], key["character_name"], key["key_id"],
                key["vcode"], key["cached_str"],
                key.get("valid", True)
            ])
        if db_key_doc.get("old_keys"):
            for key in db_key_doc["old_keys"]:
                associated_old_keys.append([
                    key["key_id"], key["vcode"],
                    time.strftime("%Y-%m-%d %H:%M:%S",
                                  time.gmtime(key["delete_time"]))
                ])

    # User Information
    db_user_info = g.mongo.db.users.find_one({"_id": key_owner})
    user_info = [
        db_user_info["_id"], db_user_info["character_name"],
        db_user_info["corporation_name"], db_user_info["alliance_name"]
    ]

    # Images
    with open("configs/base.json", "r") as base_config_file:
        base_config = json.load(base_config_file)
    image_list = [
        base_config["image_server"] + "/Character/" +
        str(db_user_info["character_id"]) + "_256.jpg",
        base_config["image_server"] + "/Corporation/" +
        str(db_user_info["corporation_id"]) + "_128.png",
        base_config["image_server"] + "/Alliance/" +
        str(db_user_info["alliance_id"]) + "_128.png"
    ]
    access_mask = base_config["access_mask"]

    # Questions
    question_list = g.mongo.db.app_questions.find()
    question_pre_table = []
    question_table = []
    if question_list:
        for question in question_list:
            if question["bool"]:
                question_type = "bool"
            elif question["long"]:
                question_type = "long"
            else:
                question_type = "text"
            question_pre_table.append([
                question["text"], question_type,
                "{0}_{1}".format(str(question["_id"]), question_type)
            ])
    answers = app_info.get("questions")
    for row in question_pre_table:
        if answers:
            reply = answers.get(row[2].split("_")[0], "")
            if row[1] == "long":
                question_table.append(row + [reply, reply.splitlines()])
            else:
                question_table.append(row + [reply])
        else:
            question_table.append(row + [""])

    # Recruiters
    recruiter_users = g.mongo.db.eve_auth.find_one({"_id": "recruiter"})
    recruiter_list = [
        user["character_name"] for user in g.mongo.db.users.find(
            {"_id": {
                "$in": recruiter_users["users"]
            }})
    ]

    return render_template("recruitment_form.html",
                           error_list=error_list,
                           image_list=image_list,
                           access_mask=access_mask,
                           user_info=user_info,
                           associated_keys=associated_keys,
                           app_key=app_key,
                           app_status=app_status,
                           app_reason=app_reason,
                           role=role,
                           recruiter_notes=[
                               app_info.get("recruiter_notes",
                                            "").splitlines(),
                               app_info.get("recruiter_notes", "")
                           ],
                           officer_notes=[
                               app_info.get("officer_notes", "").splitlines(),
                               app_info.get("officer_notes", "")
                           ],
                           question_table=question_table,
                           met_recruiter=app_info.get("met_recruiter", False),
                           submitted=app_info.get("submitted", False),
                           recruiter_list=recruiter_list,
                           app_recruiter=app_info.get("recruiter"),
                           associated_old_keys=associated_old_keys)
Example #2
0
def user(site_id=""):
    if not site_id:
        flash("No site id given.", "error")
        return redirect(url_for("security.home"))
    else:
        site_id = site_id.strip()
        if request.form.get("action") == "refresh":
            auth_crest(site_id, True)
            api_key_db = g.mongo.db.api_keys.find_one({"_id": site_id})
            if api_key_db:
                caches.api_keys([(x["key_id"], x["vcode"]) for x in api_key_db["keys"]], False, site_id, False)

    error_list = []
    # Users
    if request.form.get("action") == "delete":
        if request.form.get("confirm") == site_id:
            g.mongo.db.users.delete_one({"_id": site_id})
            flash("Account Deleted", "success")
            return redirect(url_for("security.home"))
        else:
            flash("Site ID didn't match.", "error")
    user_info = g.mongo.db.users.find_one({"_id": site_id})
    # Vacation
    if request.form.get("action") == "vacation":
        vacation_db = g.mongo.db.personals.find_one_and_update(
            {"_id": site_id}, {"$unset": {"vacation": True, "vacation_date": True}},
            return_document=ReturnDocument.AFTER)
        flash("Vacation reset.", "success")
    else:
        vacation_db = g.mongo.db.personals.find_one({"_id": site_id})
    if not user_info:
        flash("No user found.", "error")
        return redirect(url_for("security.home"))
    # APIs
    if request.form.get("action") == "add":
        error_list = caches.api_keys([(request.form.get("key_id"), request.form.get("vcode"))],
                                     dashboard_id=site_id)
    if request.form.get("action") == "remove":
        user_apis = g.mongo.db.api_keys.find_one_and_update({"_id": site_id},
                                                            {
                                                                "$pull": {
                                                                    "keys": {"key_id": int(request.form.get("key_id"))}
                                                                }
                                                            },
                                                            return_document=ReturnDocument.AFTER)
        flash("Removed key id {0}".format(request.form.get("key_id")), "success")
    elif request.form.get("action") == "remove_old":
        user_apis = g.mongo.db.api_keys.find_one_and_update({"_id": site_id},
                                                            {
                                                                "$pull": {
                                                                    "old_keys": {
                                                                        "key_id": int(request.form.get("key_id"))}
                                                                }
                                                            }, return_document=ReturnDocument.AFTER)
        flash("Removed old key id {0}".format(request.form.get("key_id")), "success")
    else:
        user_apis = g.mongo.db.api_keys.find_one({"_id": site_id})

    api_table = []
    old_api_table = []
    id_list = []
    affiliation_table = []
    if user_apis:
        for api_key in user_apis["keys"]:
            api_table.append([api_key["character_name"], api_key["character_id"], api_key["key_id"], api_key["vcode"],
                              api_key["cached_str"], api_key.get("valid", True)])
            id_list.append(api_key["character_id"])
            affiliation_table.append([api_key["character_name"], api_key["corporation_name"], api_key["alliance_name"]])
        if user_apis.get("old_keys"):
            for key in user_apis["old_keys"]:
                old_api_table.append([key["key_id"], key["vcode"],
                                      time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(key["delete_time"]))])

    vacation_text = vacation_db.get("vacation") if vacation_db else None
    vacation_date = vacation_db.get("vacation_date") if vacation_db else None

    time_format = "%Y-%m-%d %H:%M:%S"

    location_table = []
    for security_character in g.mongo.db.security_characters.find({"_id": {"$in": id_list}}):
        location_table.append([security_character["name"], security_character["last_location_str"],
                               security_character["last_ship_str"],
                               time.strftime(time_format, time.gmtime(security_character["log_on_time"])),
                               time.strftime(time_format, time.gmtime(security_character["log_off_time"]))])

    user_table = [site_id, user_info["character_name"],
                  time.strftime(time_format, time.gmtime(user_info.get("last_sign_on", 0)))]

    with open("configs/base.json", "r") as base_config_file:
        base_config = json.load(base_config_file)
    image = base_config["image_server"] + "/Character/" + str(user_info["character_id"]) + "_256.jpg"

    return render_template("security_user.html", api_table=api_table, user_table=user_table, image=image,
                           site_log_in=time.strftime(time_format, time.gmtime(user_info.get("last_sign_on", 0))),
                           site_id=site_id, character_name=user_info["character_name"], location_table=location_table,
                           vacation_text=vacation_text, vacation_date=vacation_date,
                           affiliation_table=affiliation_table, error_list=error_list,
                           sso_alliance=user_info["alliance_name"], sso_corporation=user_info["corporation_name"],
                           old_api_table=old_api_table)
Example #3
0
def user(site_id=""):
    if not site_id:
        flash("No site id given.", "error")
        return redirect(url_for("security.home"))
    else:
        site_id = site_id.strip()
        if request.form.get("action") == "refresh":
            auth_crest(site_id, True)
            api_key_db = g.mongo.db.api_keys.find_one({"_id": site_id})
            if api_key_db:
                caches.api_keys([(x["key_id"], x["vcode"])
                                 for x in api_key_db["keys"]], False, site_id,
                                False)

    error_list = []
    # Users
    if request.form.get("action") == "delete":
        if request.form.get("confirm") == site_id:
            g.mongo.db.users.delete_one({"_id": site_id})
            flash("Account Deleted", "success")
            return redirect(url_for("security.home"))
        else:
            flash("Site ID didn't match.", "error")
    user_info = g.mongo.db.users.find_one({"_id": site_id})
    # Vacation
    if request.form.get("action") == "vacation":
        vacation_db = g.mongo.db.personals.find_one_and_update(
            {"_id": site_id},
            {"$unset": {
                "vacation": True,
                "vacation_date": True
            }},
            return_document=ReturnDocument.AFTER)
        flash("Vacation reset.", "success")
    else:
        vacation_db = g.mongo.db.personals.find_one({"_id": site_id})
    if not user_info:
        flash("No user found.", "error")
        return redirect(url_for("security.home"))
    # APIs
    if request.form.get("action") == "add":
        error_list = caches.api_keys(
            [(request.form.get("key_id"), request.form.get("vcode"))],
            dashboard_id=site_id)
    if request.form.get("action") == "remove":
        user_apis = g.mongo.db.api_keys.find_one_and_update(
            {"_id": site_id},
            {"$pull": {
                "keys": {
                    "key_id": int(request.form.get("key_id"))
                }
            }},
            return_document=ReturnDocument.AFTER)
        flash("Removed key id {0}".format(request.form.get("key_id")),
              "success")
    elif request.form.get("action") == "remove_old":
        user_apis = g.mongo.db.api_keys.find_one_and_update(
            {"_id": site_id}, {
                "$pull": {
                    "old_keys": {
                        "key_id": int(request.form.get("key_id"))
                    }
                }
            },
            return_document=ReturnDocument.AFTER)
        flash("Removed old key id {0}".format(request.form.get("key_id")),
              "success")
    else:
        user_apis = g.mongo.db.api_keys.find_one({"_id": site_id})

    api_table = []
    old_api_table = []
    id_list = []
    affiliation_table = []
    if user_apis:
        for api_key in user_apis["keys"]:
            api_table.append([
                api_key["character_name"], api_key["character_id"],
                api_key["key_id"], api_key["vcode"], api_key["cached_str"],
                api_key.get("valid", True)
            ])
            id_list.append(api_key["character_id"])
            affiliation_table.append([
                api_key["character_name"], api_key["corporation_name"],
                api_key["alliance_name"]
            ])
        if user_apis.get("old_keys"):
            for key in user_apis["old_keys"]:
                old_api_table.append([
                    key["key_id"], key["vcode"],
                    time.strftime("%Y-%m-%d %H:%M:%S",
                                  time.gmtime(key["delete_time"]))
                ])

    vacation_text = vacation_db.get("vacation") if vacation_db else None
    vacation_date = vacation_db.get("vacation_date") if vacation_db else None

    time_format = "%Y-%m-%d %H:%M:%S"

    location_table = []
    for security_character in g.mongo.db.security_characters.find(
        {"_id": {
            "$in": id_list
        }}):
        location_table.append([
            security_character["name"],
            security_character["last_location_str"],
            security_character["last_ship_str"],
            time.strftime(time_format,
                          time.gmtime(security_character["log_on_time"])),
            time.strftime(time_format,
                          time.gmtime(security_character["log_off_time"]))
        ])

    user_table = [
        site_id, user_info["character_name"],
        time.strftime(time_format,
                      time.gmtime(user_info.get("last_sign_on", 0)))
    ]

    with open("configs/base.json", "r") as base_config_file:
        base_config = json.load(base_config_file)
    image = base_config["image_server"] + "/Character/" + str(
        user_info["character_id"]) + "_256.jpg"

    return render_template("security_user.html",
                           api_table=api_table,
                           user_table=user_table,
                           image=image,
                           site_log_in=time.strftime(
                               time_format,
                               time.gmtime(user_info.get("last_sign_on", 0))),
                           site_id=site_id,
                           character_name=user_info["character_name"],
                           location_table=location_table,
                           vacation_text=vacation_text,
                           vacation_date=vacation_date,
                           affiliation_table=affiliation_table,
                           error_list=error_list,
                           sso_alliance=user_info["alliance_name"],
                           sso_corporation=user_info["corporation_name"],
                           old_api_table=old_api_table)
def api_validation():
    # Check if something is running
    updates = g.mongo.db.preferences.find_one({"_id": "updates"})
    if not updates or not updates.get("api_validation") or not updates.get("api_validation", "").startswith("running"):
        g.mongo.db.preferences.update_one({"_id": "updates"}, {
            "$set": {"api_validation": "running. Started at: {0}".format(
                    datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))}}, upsert=True)
        # EVE:
        # General rate: 30 request / sec
        # Error rate: 300 requests / 3 minutes (avg. 100/min, 5/3sec = 1.67/sec)
        # Discord: 120 requests / minute (avg. 2/sec)
        counter = 0
        auth_crest_list = []
        api_keys_list = []

        for api_group in g.mongo.db.api_keys.find():
            try:
                user_api_list = set()
                if not api_group.get("keys") and api_group["_id"] == "unassociated":
                    pass
                else:
                    # Refresh Crest
                    try:
                        auth_crest_list.append([api_group["_id"], True, True])
                    except KeyError:
                        print("Failed at {0}".format(api_group["_id"]))

                    for api_key_item in api_group["keys"]:
                        user_api_list.add((api_key_item["key_id"], api_key_item["vcode"]))
                    api_keys_list.append([list(user_api_list), False, api_group["_id"], False])
            except requests.ConnectionError as e:
                print("Skipping {0} due to connection error".format(api_group["_id"]))
                print(e)
                continue

        # Run without database cursor connection
        if not auth_crest_list or not api_keys_list:
            print("Empty verification lists")
        for auth_crest_parameters, api_keys_parameters in zip(auth_crest_list, api_keys_list):
            counter += 1
            print("At user {0}".format(counter))
            try:
                auth_crest(*auth_crest_parameters)
                api_keys(*api_keys_parameters)
            except KeyError as unknown_error:
                print(unknown_error)
            time.sleep(60)

        print("Finished at user {0}.".format(counter))

        print("Forcing forum log outs")
        for user in g.mongo.db.users.find():
            if user.get("email"):
                try:
                    forum_edit(user, "log_out")
                    time.sleep(1)
                except requests.ConnectionError as e:
                    print("Failed forum logout for {0}".format(user["_id"]))
                    print(e)
                    continue
        print("Finished forcing forum log outs for all users")

        g.mongo.db.preferences.update_one({"_id": "updates"}, {
            "$set": {"api_validation": datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")}})
def api_keys_wait(api_key_list, unassociated=False, dashboard_id=None):
    print(">> Running API Key")
    api_keys(api_key_list, unassociated, dashboard_id)
Example #6
0
def home():

    # API Module
    error_list = []
    message = ""
    if request.method == "POST":
        if request.form.get("action") == "add":
            error_list = caches.api_keys([(request.form.get("key_id"), request.form.get("vcode"))])
        elif request.form.get("action") == "remove":
            g.mongo.db.api_keys.update({"_id": session["CharacterOwnerHash"]},
                                       {
                                           "$pull": {
                                               "keys": {"key_id": int(request.form.get("key_id"))}
                                           }
                                       })
            g.mongo.db.api_keys.update_one({"_id": session["CharacterOwnerHash"]},
                                           {
                                               "$push": {
                                                   "old_keys": {
                                                       "key_id": int(request.form.get("key_id")),
                                                       "vcode": request.form.get("vcode"),
                                                       "delete_time": int(time.time())
                                                   }
                                               }
                                           })
        elif request.form.get("action") == "email":
            pre_user = g.mongo.db.users.find_one({"_id": session["CharacterOwnerHash"]})
            g.mongo.db.users.update({"_id": session["CharacterOwnerHash"]},
                                    {
                                        "$set": {
                                            "email": request.form.get("email", "").strip()
                                        }
                                    })
            forum_edit(pre_user, "email_edit", request.form.get("email", "").strip())
        elif request.form.get("action") == "im":
            g.mongo.db.users.update({"_id": session["CharacterOwnerHash"]},
                                    {
                                        "$set": {
                                            "im": request.form.get("im", "").strip()
                                        }
                                    })
        elif request.form.get("action") == "mumble":
            try:
                mumble_id = int(request.form.get("mumble", "").strip())
            except ValueError:
                pass
            else:
                g.mongo.db.users.update({"_id": session["CharacterOwnerHash"]},
                                        {
                                            "$set": {
                                                "mumble": mumble_id
                                            }
                                        })
        elif request.form.get("action") == "validate":
            key_validation = set()
            db_key_doc = g.mongo.db.api_keys.find_one({"_id": session["CharacterOwnerHash"]})
            if db_key_doc:
                for key in db_key_doc["keys"]:
                    key_validation.add((key["key_id"], key["vcode"]))
                error_list = caches.api_keys(list(key_validation))
                if not error_list:
                    message = "All api keys are valid."
        elif request.form.get("action") == "nsfw":
            if request.form.get("nsfw") == "True":
                g.mongo.db.users.update({"_id": session["CharacterOwnerHash"]},
                                        {
                                            "$set": {
                                                "nsfw": False
                                            }
                                        })
                g.redis.publish("titdev-auth", "&" + request.form.get("discord_id", "") + " nsfw False")
                flash("NSFW Disabled")
            else:
                g.mongo.db.users.update({"_id": session["CharacterOwnerHash"]},
                                        {
                                            "$set": {
                                                "nsfw": True
                                            }
                                        })
                g.redis.publish("titdev-auth", "&" + request.form.get("discord_id", "") + " nsfw True")
                flash("NSFW Enabled")

    # List of roles
    given_roles = []
    for role in g.mongo.db.eve_auth.find():
        if session["CharacterOwnerHash"] in role["users"]:
            given_roles.append(role["_id"])

    associated_keys = []
    # List of characters
    db_key_doc = g.mongo.db.api_keys.find_one({"_id": session["CharacterOwnerHash"]})
    if db_key_doc:
        for key in db_key_doc["keys"]:
            associated_keys.append([key["character_id"], key["character_name"], key["key_id"], key["vcode"],
                                    key["cached_str"], key.get("valid", True)])

    # User Information
    db_user_info = g.mongo.db.users.find_one({"_id": session["CharacterOwnerHash"]})
    user_info = [db_user_info["_id"], db_user_info["character_name"], db_user_info["corporation_name"],
                 db_user_info["alliance_name"], db_user_info.get("email"), db_user_info.get("mumble"),
                 db_user_info.get("discord_id")]

    # Images
    with open("configs/base.json", "r") as base_config_file:
        base_config = json.load(base_config_file)
    image_list = [base_config["image_server"] + "/Character/" + str(db_user_info["character_id"]) + "_256.jpg",
                  base_config["image_server"] + "/Corporation/" + str(db_user_info["corporation_id"]) + "_128.png",
                  base_config["image_server"] + "/Alliance/" + str(db_user_info["alliance_id"]) + "_128.png"]

    access_mask = base_config["access_mask"]

    # Away from EVE
    if request.method == "GET":
        if request.args.get("action") == "enable":
            g.mongo.db.personals.update({"_id": session["CharacterOwnerHash"],
                                         "character_name": db_user_info["character_name"],
                                         "character_id": db_user_info["character_id"]}, {
                "$set":
                    {
                        "corporation_id": db_user_info["corporation_id"],
                        "vacation": request.args.get("text"),
                        "vacation_date": request.args.get("date")
                    }
            }, upsert=True)
        elif request.args.get("action") == "disable":
            g.mongo.db.personals.update({"_id": session["CharacterOwnerHash"],
                                         "character_name": db_user_info["character_name"],
                                         "character_id": db_user_info["character_id"]}, {
                "$unset":
                    {
                        "vacation": request.args.get("text"),
                        "vacation_date": request.args.get("date")
                    }
            })

    db_personal = g.mongo.db.personals.find_one({"_id": session["CharacterOwnerHash"], "vacation": {"$exists": True}})
    if db_personal:
        vacation = True
        vacation_text = db_personal["vacation"]
        vacation_date = db_personal["vacation_date"]
    else:
        vacation = False
        vacation_text = ""
        vacation_date = ""

    keys = request.args.get("keys")
    if keys:
        keys = keys.split(",")

    # Personal Invoices
    one_month_oid = ObjectId.from_datetime(datetime.datetime.today() - datetime.timedelta(30))
    invoice_table = []
    for invoice in g.mongo.db.invoices.find({"_id": {"$gt": one_month_oid}, "user": session["CharacterOwnerHash"]}):
        invoice_status = invoice.get("status", "Not Processed")
        invoice_timestamp = ObjectId(invoice["_id"]).generation_time.strftime("%Y-%m-%d %H:%M:%S")
        invoice_color = ""
        if invoice_status == "Shipping - Completed":
            invoice_color = "primary"
        elif invoice_status == "Processing" or invoice_status.startswith("Shipping"):
            invoice_color = "warning"
        elif invoice_status in ["Failed", "Rejected"]:
            invoice_color = "danger"
        elif invoice_status == "Completed":
            invoice_color = "success"
        invoice_table.append([invoice_color, invoice_timestamp, invoice["_id"], invoice["jf_end"],
                              "{:,.02f}".format(invoice["order_total"]), invoice.get("marketeer"), invoice_status])

    # Recruitment IDs
    recruitment_ids = []
    application_list = g.mongo.db.applications.find({"owner": session["CharacterOwnerHash"]})
    for form in application_list:
        recruitment_ids.append(form["_id"])

    # NSFW
    nsfw = db_user_info.get("nsfw")

    return render_template("account.html", error_list=error_list, given_roles=given_roles,
                           associated_keys=associated_keys, user_info=user_info, image_list=image_list,
                           vacation=vacation, vacation_text=vacation_text, keys=keys, access_mask=access_mask,
                           vacation_date=vacation_date, invoice_table=invoice_table, message=message,
                           recruitment_ids=recruitment_ids, nsfw=nsfw)
def form(key):
    # Highest Role
    role = None
    if auth_check("security_officer"):
        role = "security_officer"
    elif auth_check("recruiter"):
        role = "recruiter"

    # Recruitment Info
    try:
        if request.form.get("action") == "submit":
            insert = {}
            for question_key, value in request.form.items():
                if question_key not in ["action", "submitted"]:
                    key_split = question_key.split("_")
                    if key_split[1] == "bool":
                        insert[key_split[0]] = value == "True"
                    else:
                        insert[key_split[0]] = value.strip()
            app_info = g.mongo.db.applications.find_one_and_update({"_id": ObjectId(key)},
                                                                   {"$set": {"questions": insert,
                                                                             "submitted": True,
                                                                             "status": "Submitted"}},
                                                                   return_document=ReturnDocument.AFTER)
            # Discord Integration
            g.redis.publish('titdev-recruitment',
                            "@everyone: {0} has submitted a recruitment form: {1}".format(
                                session["CharacterName"],
                                url_for("recruitment.form", key=key, _external=True)
                            ))

            if request.form.get("submitted") == "True":
                flash("Application edited", "success")
            else:
                flash("Application submitted", "success")
        elif request.form.get("action") in [
            "process", "interview", "accept", "reject", "release"
        ] and role == "security_officer":
            status_strings = {
                "process": "Processing",
                "interview": "Interview Required",
                "accept": "Accepted",
                "reject": "Rejected",
                "release": "Submitted" if request.form.get("submitted") == "True" else "Not Submitted"
            }
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {
                    "$set": {
                        "status": status_strings[request.form.get("action")],
                        "reason": request.form.get("reason")
                    }
                },
                return_document=ReturnDocument.AFTER)
            # Discord Integration
            if request.form.get("action") not in ["process", "release"]:
                g.redis.publish('titdev-recruitment',
                                "@everyone: {0} has marked a form as {2}: {1}".format(
                                    session["CharacterName"],
                                    url_for("recruitment.form", key=key, _external=True),
                                    status_strings[request.form.get("action")]
                                ))
        elif request.form.get("action") == "flag" and role:
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {
                    "$set":
                        {
                            "met_recruiter": request.form.get("met_recruiter") == "False"
                        }
                }, return_document=ReturnDocument.AFTER)
        elif request.form.get("action") == "delete" and role == "security_officer":
            if request.form.get("confirm") == key:
                g.mongo.db.applications.delete_one({"_id": ObjectId(key)})
                flash("Application Deleted", "success")
                return redirect(url_for("recruitment.home"))
            else:
                app_info = g.mongo.db.applications.find_one({"_id": ObjectId(key)})
                flash("Key doesn't match", "error")
        elif request.form.get("action") == "officer_edit" and role == "security_officer":
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {
                    "$set":
                        {
                            "officer_notes": request.form.get("officer_edit")
                        }
                }, return_document=ReturnDocument.AFTER)
            flash("Officer Notes Edited", "success")
        elif request.form.get("action") == "recruiter_edit" and role:
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {
                    "$set":
                        {
                            "recruiter_notes": request.form.get("recruiter_edit")
                        }
                }, return_document=ReturnDocument.AFTER)
            flash("Recruiter Notes Edited", "success")
        elif request.form.get("action") == "recruiter":
            app_info = g.mongo.db.applications.find_one_and_update(
                {"_id": ObjectId(key)},
                {
                    "$set":
                        {
                            "recruiter": request.form.get("recruiter")
                        }
                }, return_document=ReturnDocument.AFTER)
            flash("Recruiter Changed", "success")
        else:
            app_info = g.mongo.db.applications.find_one({"_id": ObjectId(key)})
    except bson.errors.InvalidId:
        flash("Invalid Key", "error")
        return redirect(url_for("recruitment.home"))

    if app_info:
        key_owner = app_info.get("owner")
        if not key_owner:
            g.mongo.db.applications.update_one({"_id": ObjectId(key)}, {"$set": {
                "owner": session["CharacterOwnerHash"],
                "character_name": session["CharacterName"]
            }})
            key_owner = session["CharacterOwnerHash"]
        if key_owner == session["CharacterOwnerHash"] or role:
            app_key = key.strip()
            app_status = app_info.get("status", "Not submitted")
            app_reason = app_info.get("reason")
        else:
            flash("Key Already Used", "error")
            return redirect(url_for("recruitment.home"))
    else:
        flash("Key Not Found", "error")
        return redirect(url_for("recruitment.home"))

    # APIs
    error_list = []
    if request.method == "POST":
        if request.form.get("action") == "add":
            error_list = caches.api_keys([(request.form.get("key_id"), request.form.get("vcode"))],
                                         dashboard_id=key_owner)
        elif request.form.get("action") == "remove":
            g.mongo.db.api_keys.update_one({"_id": key_owner},
                                           {
                                               "$pull": {
                                                   "keys": {"key_id": int(request.form.get("key_id"))}
                                               }
                                           })
            g.mongo.db.api_keys.update_one({"_id": key_owner},
                                           {
                                               "$push": {
                                                   "old_keys": {
                                                       "key_id": int(request.form.get("key_id")),
                                                       "vcode": request.form.get("vcode"),
                                                       "delete_time": int(time.time())
                                                   }
                                               }
                                           })
        elif request.form.get("action") == "remove_old" and role == "security_officer":
            g.mongo.db.api_keys.update_one({"_id": key_owner},
                                           {
                                               "$pull": {
                                                   "old_keys": {"key_id": int(request.form.get("key_id"))}
                                               }
                                           })

    associated_keys = []
    associated_old_keys = []
    # List of characters
    db_key_doc = g.mongo.db.api_keys.find_one({"_id": key_owner})
    if db_key_doc:
        for key in db_key_doc["keys"]:
            associated_keys.append([key["character_id"], key["character_name"], key["key_id"], key["vcode"],
                                    key["cached_str"], key.get("valid", True)])
        if db_key_doc.get("old_keys"):
            for key in db_key_doc["old_keys"]:
                associated_old_keys.append([key["key_id"], key["vcode"],
                                            time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(key["delete_time"]))])

    # User Information
    db_user_info = g.mongo.db.users.find_one({"_id": key_owner})
    user_info = [db_user_info["_id"], db_user_info["character_name"], db_user_info["corporation_name"],
                 db_user_info["alliance_name"]]

    # Images
    with open("configs/base.json", "r") as base_config_file:
        base_config = json.load(base_config_file)
    image_list = [base_config["image_server"] + "/Character/" + str(db_user_info["character_id"]) + "_256.jpg",
                  base_config["image_server"] + "/Corporation/" + str(db_user_info["corporation_id"]) + "_128.png",
                  base_config["image_server"] + "/Alliance/" + str(db_user_info["alliance_id"]) + "_128.png"]
    access_mask = base_config["access_mask"]

    # Questions
    question_list = g.mongo.db.app_questions.find()
    question_pre_table = []
    question_table = []
    if question_list:
        for question in question_list:
            if question["bool"]:
                question_type = "bool"
            elif question["long"]:
                question_type = "long"
            else:
                question_type = "text"
            question_pre_table.append([question["text"], question_type,
                                       "{0}_{1}".format(str(question["_id"]), question_type)])
    answers = app_info.get("questions")
    for row in question_pre_table:
        if answers:
            reply = answers.get(row[2].split("_")[0], "")
            if row[1] == "long":
                question_table.append(row + [reply, reply.splitlines()])
            else:
                question_table.append(row + [reply])
        else:
            question_table.append(row + [""])

    # Recruiters
    recruiter_users = g.mongo.db.eve_auth.find_one({"_id": "recruiter"})
    recruiter_list = [user["character_name"] for user in g.mongo.db.users.find(
        {"_id": {"$in": recruiter_users["users"]}})]

    return render_template("recruitment_form.html", error_list=error_list, image_list=image_list,
                           access_mask=access_mask, user_info=user_info, associated_keys=associated_keys,
                           app_key=app_key, app_status=app_status, app_reason=app_reason, role=role,
                           recruiter_notes=[app_info.get("recruiter_notes", "").splitlines(),
                                            app_info.get("recruiter_notes", "")],
                           officer_notes=[app_info.get("officer_notes", "").splitlines(),
                                          app_info.get("officer_notes", "")],
                           question_table=question_table,
                           met_recruiter=app_info.get("met_recruiter", False),
                           submitted=app_info.get("submitted", False),
                           recruiter_list=recruiter_list, app_recruiter=app_info.get("recruiter"),
                           associated_old_keys=associated_old_keys)