7 files changed, 334 insertions, 59 deletions

diff --git a/backend/handlers/record.go b/backend/handlers/record.go
index fea6b5d..2338097 100644
--- a/backend/handlers/record.go
+++ b/backend/handlers/record.go
@@ -24,10 +24,9 @@ import (
 )
 
 type RecordRequest struct {
-        HostDemo        *multipart.FileHeader `json:"host_demo" form:"host_demo" binding:"required" swaggerignore:"true"`
-        PartnerDemo     *multipart.FileHeader `json:"partner_demo" form:"partner_demo" swaggerignore:"true"`
-        IsPartnerOrange bool                  `json:"is_partner_orange" form:"is_partner_orange"`
-        PartnerID       string                `json:"partner_id" form:"partner_id"`
+        HostDemo    *multipart.FileHeader `json:"host_demo" form:"host_demo" binding:"required" swaggerignore:"true"`
+        PartnerDemo *multipart.FileHeader `json:"partner_demo" form:"partner_demo" swaggerignore:"true"`
+        PartnerID   string                `json:"partner_id" form:"partner_id"`
 }
 
 type RecordResponse struct {
@@ -50,7 +49,12 @@ type RecordResponse struct {
 //      @Success                200                                     {object}        models.Response{data=RecordResponse}
 //      @Router                 /maps/{mapid}/record [post]
 func CreateRecordWithDemo(c *gin.Context) {
-        mapId := c.Param("mapid")
+        id := c.Param("mapid")
+        mapID, err := strconv.Atoi(id)
+        if err != nil {
+                c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
+                return
+        }
         // Check if user exists
         user, exists := c.Get("user")
         if !exists {
@@ -62,7 +66,7 @@ func CreateRecordWithDemo(c *gin.Context) {
         var isCoop bool
         var isDisabled bool
         sql := `SELECT g.name, m.is_disabled FROM maps m INNER JOIN games g ON m.game_id=g.id WHERE m.id = $1`
-        err := database.DB.QueryRow(sql, mapId).Scan(&gameName, &isDisabled)
+        err = database.DB.QueryRow(sql, mapID).Scan(&gameName, &isDisabled)
         if err != nil {
                 c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
                 return
@@ -94,8 +98,8 @@ func CreateRecordWithDemo(c *gin.Context) {
         var hostDemoUUID, hostDemoFileID, partnerDemoUUID, partnerDemoFileID string
         var hostDemoScoreCount, hostDemoScoreTime int
         var hostSteamID, partnerSteamID string
-        client := serviceAccount()
-        srv, err := drive.New(client)
+        var hostDemoServerNumber, partnerDemoServerNumber int
+        srv, err := drive.New(serviceAccount())
         if err != nil {
                 c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
                 return
@@ -131,13 +135,22 @@ func CreateRecordWithDemo(c *gin.Context) {
                         c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
                         return
                 }
-                hostDemoScoreCount, hostDemoScoreTime, hostSteamID, partnerSteamID, err = parser.ProcessDemo("backend/parser/" + uuid + ".dem")
+                parserResult, err := parser.ProcessDemo("backend/parser/" + uuid + ".dem")
                 if err != nil {
                         deleteFile(srv, file.Id)
                         CreateLog(user.(models.User).SteamID, LogTypeRecord, LogDescriptionCreateRecordProcessDemoFail, err.Error())
                         c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
                         return
                 }
+                if mapID != parserResult.MapID {
+                        deleteFile(srv, file.Id)
+                        c.JSON(http.StatusOK, models.ErrorResponse("demo map does not match uploaded map id"))
+                        return
+                }
+                hostDemoScoreCount = parserResult.PortalCount
+                hostDemoScoreTime = parserResult.TickCount
+                hostSteamID = parserResult.HostSteamID
+                partnerSteamID = parserResult.PartnerSteamID
                 if hostDemoScoreCount == 0 && hostDemoScoreTime == 0 {
                         deleteFile(srv, file.Id)
                         CreateLog(user.(models.User).SteamID, LogTypeRecord, LogDescriptionCreateRecordProcessDemoFail, err.Error())
@@ -145,30 +158,32 @@ func CreateRecordWithDemo(c *gin.Context) {
                         return
                 }
                 if !isCoop {
-                        hostSplit := strings.Split(hostSteamID, ":")
-                        if hostSplit[len(hostSplit)-1] != user.(models.User).SteamID {
-                                c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Host SteamID from demo and request does not match! Check your submission and try again.\nDemo Host SteamID: %s\nRequest Host SteamID: %s", hostSplit[len(hostSplit)-1], user.(models.User).SteamID)))
+                        convertedSteamID := strconv.FormatInt(convertSteamID64(hostSteamID), 10)
+                        if convertedSteamID != user.(models.User).SteamID {
+                                deleteFile(srv, file.Id)
+                                c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Host SteamID from demo and request does not match! Check your submission and try again.\nDemo Host SteamID: %s\nRequest Host SteamID: %s", convertedSteamID, user.(models.User).SteamID)))
                                 return
                         }
                 } else {
-                        partnerSplit := strings.Split(partnerSteamID, ":")
-                        if partnerSplit[len(partnerSplit)-1] != record.PartnerID {
-                                c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Partner SteamID from demo and request does not match! Check your submission and try again.\nDemo Partner SteamID: %s\nRequest Partner SteamID: %s", partnerSplit[len(partnerSplit)-1], record.PartnerID)))
+                        if parserResult.IsHost && i != 0 {
+                                deleteFile(srv, file.Id)
+                                c.JSON(http.StatusOK, models.ErrorResponse("Given partner demo is a host demo."))
                                 return
                         }
-                        var verifyCoopSteamID string
-                        database.DB.QueryRow("SELECT steam_id FROM users WHERE steam_id = $1", record.PartnerID).Scan(&verifyCoopSteamID)
-                        if verifyCoopSteamID != record.PartnerID {
-                                c.JSON(http.StatusOK, models.ErrorResponse("Given partner SteamID does not match an account on LPHUB."))
+                        if !parserResult.IsHost && i == 0 {
+                                deleteFile(srv, file.Id)
+                                c.JSON(http.StatusOK, models.ErrorResponse("Given host demo is a partner demo."))
                                 return
                         }
                 }
                 if i == 0 {
                         hostDemoFileID = file.Id
                         hostDemoUUID = uuid
+                        hostDemoServerNumber = parserResult.ServerNumber
                 } else if i == 1 {
                         partnerDemoFileID = file.Id
                         partnerDemoUUID = uuid
+                        partnerDemoServerNumber = parserResult.ServerNumber
                 }
                 _, err = tx.Exec(`INSERT INTO demos (id,location_id) VALUES ($1,$2)`, uuid, file.Id)
                 if err != nil {
@@ -180,18 +195,37 @@ func CreateRecordWithDemo(c *gin.Context) {
         }
         // Insert into records
         if isCoop {
+                if hostDemoServerNumber != partnerDemoServerNumber {
+                        deleteFile(srv, hostDemoFileID)
+                        deleteFile(srv, partnerDemoFileID)
+                        c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Host and partner demo server numbers (%d & %d) does not match!", hostDemoServerNumber, partnerDemoServerNumber)))
+                        return
+                }
+                convertedHostSteamID := strconv.FormatInt(convertSteamID64(hostSteamID), 10)
+                if convertedHostSteamID != user.(models.User).SteamID && convertedHostSteamID != record.PartnerID {
+                        deleteFile(srv, hostDemoFileID)
+                        deleteFile(srv, partnerDemoFileID)
+                        c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Host SteamID from demo and request does not match! Check your submission and try again.\nDemo Host SteamID: %s\nRequest Host SteamID: %s", convertedHostSteamID, user.(models.User).SteamID)))
+                        return
+                }
+                convertedPartnerSteamID := strconv.FormatInt(convertSteamID64(partnerSteamID), 10)
+                if convertedPartnerSteamID != record.PartnerID && convertedPartnerSteamID != user.(models.User).SteamID {
+                        deleteFile(srv, hostDemoFileID)
+                        deleteFile(srv, partnerDemoFileID)
+                        c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Partner SteamID from demo and request does not match! Check your submission and try again.\nDemo Partner SteamID: %s\nRequest Partner SteamID: %s", convertedPartnerSteamID, record.PartnerID)))
+                        return
+                }
+                var verifyPartnerSteamID string
+                database.DB.QueryRow("SELECT steam_id FROM users WHERE steam_id = $1", record.PartnerID).Scan(&verifyPartnerSteamID)
+                if verifyPartnerSteamID != record.PartnerID {
+                        deleteFile(srv, hostDemoFileID)
+                        deleteFile(srv, partnerDemoFileID)
+                        c.JSON(http.StatusOK, models.ErrorResponse("Given partner SteamID does not match an account on LPHUB."))
+                        return
+                }
                 sql := `INSERT INTO records_mp(map_id,score_count,score_time,host_id,partner_id,host_demo_id,partner_demo_id) 
                 VALUES($1, $2, $3, $4, $5, $6, $7)`
-                var hostID string
-                var partnerID string
-                if record.IsPartnerOrange {
-                        hostID = user.(models.User).SteamID
-                        partnerID = record.PartnerID
-                } else {
-                        partnerID = user.(models.User).SteamID
-                        hostID = record.PartnerID
-                }
-                _, err := tx.Exec(sql, mapId, hostDemoScoreCount, hostDemoScoreTime, hostID, partnerID, hostDemoUUID, partnerDemoUUID)
+                _, err := tx.Exec(sql, mapID, hostDemoScoreCount, hostDemoScoreTime, strconv.FormatInt(convertSteamID64(hostSteamID), 10), strconv.FormatInt(convertSteamID64(partnerSteamID), 10), hostDemoUUID, partnerDemoUUID)
                 if err != nil {
                         deleteFile(srv, hostDemoFileID)
                         deleteFile(srv, partnerDemoFileID)
@@ -202,7 +236,7 @@ func CreateRecordWithDemo(c *gin.Context) {
         } else {
                 sql := `INSERT INTO records_sp(map_id,score_count,score_time,user_id,demo_id) 
                 VALUES($1, $2, $3, $4, $5)`
-                _, err := tx.Exec(sql, mapId, hostDemoScoreCount, hostDemoScoreTime, user.(models.User).SteamID, hostDemoUUID)
+                _, err := tx.Exec(sql, mapID, hostDemoScoreCount, hostDemoScoreTime, user.(models.User).SteamID, hostDemoUUID)
                 if err != nil {
                         deleteFile(srv, hostDemoFileID)
                         CreateLog(user.(models.User).SteamID, LogTypeRecord, LogDescriptionCreateRecordInsertRecordFail, err.Error())
diff --git a/backend/parser/parser.go b/backend/parser/parser.go
index 1a80d4a..4605600 100644
--- a/backend/parser/parser.go
+++ b/backend/parser/parser.go
@@ -4,30 +4,52 @@ import (
         "errors"
         "math"
         "os"
+        "regexp"
+        "strconv"
+        "strings"
 
         "github.com/pektezol/bitreader"
 )
 
+type Result struct {
+        MapID          int
+        ServerNumber   int
+        PortalCount    int
+        TickCount      int
+        HostSteamID    string
+        PartnerSteamID string
+        IsHost         bool
+}
+
 // Don't try to understand it, feel it.
-func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID string, partnerSteamID string, err error) {
+func ProcessDemo(filePath string) (Result, error) {
+        var result Result
         file, err := os.Open(filePath)
         if err != nil {
-                return 0, 0, "", "", err
+                return Result{}, err
         }
         reader := bitreader.NewReader(file, true)
         demoFileStamp := reader.TryReadString()
         demoProtocol := reader.TryReadSInt32()
         networkProtocol := reader.TryReadSInt32()
-        reader.SkipBytes(1056)
+        serverName := reader.TryReadStringLength(260)
+        // clientName := reader.TryReadStringLength(260)
+        reader.SkipBytes(260)
+        mapName := reader.TryReadStringLength(260)
+        reader.SkipBytes(276)
         if demoFileStamp != "HL2DEMO" {
-                return 0, 0, "", "", errors.New("invalid demo file stamp")
+                return Result{}, errors.New("invalid demo file stamp")
         }
         if demoProtocol != 4 {
-                return 0, 0, "", "", errors.New("this parser only supports demos from new engine")
+                return Result{}, errors.New("this parser only supports demos from new engine")
         }
         if networkProtocol != 2001 {
-                return 0, 0, "", "", errors.New("this parser only supports demos from portal 2")
+                return Result{}, errors.New("this parser only supports demos from portal 2")
+        }
+        if mapDict[mapName] == 0 {
+                return Result{}, errors.New("demo recorded on an invalid map")
         }
+        result.MapID = mapDict[mapName]
         for {
                 packetType := reader.TryReadUInt8()
                 reader.SkipBits(40)
@@ -119,7 +141,17 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                         packetReader.SkipBytes(2)
                                         packetReader.SkipBits(uint64(packetReader.TryReadUInt16()))
                                 case 16:
-                                        packetReader.TryReadString()
+                                        print := packetReader.TryReadString()
+                                        re := regexp.MustCompile(`Server Number: (\d+)`)
+                                        match := re.FindStringSubmatch(print)
+                                        if len(match) >= 1 {
+                                                serverNumber := match[1]
+                                                n, err := strconv.Atoi(serverNumber)
+                                                if err != nil {
+                                                        return Result{}, err
+                                                }
+                                                result.ServerNumber = n
+                                        }
                                 case 17:
                                         var length uint16
                                         if packetReader.TryReadBool() {
@@ -180,8 +212,8 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                                         NumPortals: userMessageReader.TryReadSInt32(),
                                                         TimeTaken:  userMessageReader.TryReadSInt32(),
                                                 }
-                                                portalCount = int(scoreboardTempUpdate.NumPortals)
-                                                tickCount = int(math.Round(float64((float32(scoreboardTempUpdate.TimeTaken) / 100.0) / float32(1.0/60.0))))
+                                                result.PortalCount = int(scoreboardTempUpdate.NumPortals)
+                                                result.TickCount = int(math.Round(float64((float32(scoreboardTempUpdate.TimeTaken) / 100.0) / float32(1.0/60.0))))
                                         }
                                 case 24:
                                         packetReader.SkipBits(20)
@@ -216,8 +248,8 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                         packetReader.SkipBytes(packetReader.TryReadBits(32))
                                 case 33:
                                         packetReader.SkipBits(packetReader.TryReadBits(32))
-                                default:
-                                        return 0, 0, "", "", errors.New("unknown msg type")
+                                        // default:
+                                        //      return Result{}, errors.New(fmt.Sprintf("unknown msg type %d", messageType))
                                 }
                         }
                 case 3, 7:
@@ -252,7 +284,7 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                         if stringTableReader.TryReadBool() {
                                                 byteLen, err := stringTableReader.ReadBits(16)
                                                 if err != nil {
-                                                        return 0, 0, "", "", errors.New("error on reading entry length")
+                                                        return Result{}, errors.New("error on reading entry length")
                                                 }
                                                 stringTableEntryReader := bitreader.NewReaderFromBytes(stringTableReader.TryReadBytesToSlice(byteLen), true)
                                                 if tableName == "userinfo" {
@@ -285,10 +317,14 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                                         userInfo.FilesDownloaded = stringTableEntryReader.TryReadUInt8()
                                                         stringTableEntryReader.SkipBytes(3)
                                                         if guidCount == 0 {
-                                                                hostSteamID = userInfo.GUID
+                                                                result.HostSteamID = userInfo.GUID
+                                                                if strings.Contains(serverName, "localhost") {
+                                                                        result.IsHost = true
+                                                                }
                                                         } else if guidCount == 1 {
-                                                                partnerSteamID = userInfo.GUID
+                                                                result.PartnerSteamID = userInfo.GUID
                                                         }
+                                                        guidCount++
                                                 }
                                         }
                                 }
@@ -303,11 +339,139 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID s
                                 }
                         }
                 default:
-                        return 0, 0, "", "", errors.New("invalid packet type")
+                        return Result{}, errors.New("invalid packet type")
                 }
                 if packetType == 7 {
                         break
                 }
         }
-        return portalCount, tickCount, hostSteamID, partnerSteamID, nil
+        return result, nil
+}
+
+var mapDict = map[string]int{
+        "sp_a1_intro1": 1,
+        "sp_a1_intro2": 2,
+        "sp_a1_intro3": 3,
+        "sp_a1_intro4": 4,
+        "sp_a1_intro5": 5,
+        "sp_a1_intro6": 6,
+        "sp_a1_intro7": 7,
+        "sp_a1_wakeup": 8,
+        "sp_a2_intro":  9,
+
+        "sp_a2_laser_intro":    10,
+        "sp_a2_laser_stairs":   11,
+        "sp_a2_dual_lasers":    12,
+        "sp_a2_laser_over_goo": 13,
+        "sp_a2_catapult_intro": 14,
+        "sp_a2_trust_fling":    15,
+        "sp_a2_pit_flings":     16,
+        "sp_a2_fizzler_intro":  17,
+
+        "sp_a2_sphere_peek":     18,
+        "sp_a2_ricochet":        19,
+        "sp_a2_bridge_intro":    20,
+        "sp_a2_bridge_the_gap":  21,
+        "sp_a2_turret_intro":    22,
+        "sp_a2_laser_relays":    23,
+        "sp_a2_turret_blocker":  24,
+        "sp_a2_laser_vs_turret": 25,
+        "sp_a2_pull_the_rug":    26,
+
+        "sp_a2_column_blocker": 27,
+        "sp_a2_laser_chaining": 28,
+        "sp_a2_triple_laser":   29,
+        "sp_a2_bts1":           30,
+        "sp_a2_bts2":           31,
+
+        "sp_a2_bts3": 32,
+        "sp_a2_bts4": 33,
+        "sp_a2_bts5": 34,
+        "sp_a2_core": 35,
+
+        "sp_a3_01":           36,
+        "sp_a3_03":           37,
+        "sp_a3_jump_intro":   38,
+        "sp_a3_bomb_flings":  39,
+        "sp_a3_crazy_box":    40,
+        "sp_a3_transition01": 41,
+
+        "sp_a3_speed_ramp":   42,
+        "sp_a3_speed_flings": 43,
+        "sp_a3_portal_intro": 44,
+        "sp_a3_end":          45,
+
+        "sp_a4_intro":          46,
+        "sp_a4_tb_intro":       47,
+        "sp_a4_tb_trust_drop":  48,
+        "sp_a4_tb_wall_button": 49,
+        "sp_a4_tb_polarity":    50,
+        "sp_a4_tb_catch":       51,
+        "sp_a4_stop_the_box":   52,
+        "sp_a4_laser_catapult": 53,
+        "sp_a4_laser_platform": 54,
+        "sp_a4_speed_catch":    55,
+        "sp_a4_jump_polarity":  56,
+
+        "sp_a4_finale1": 57,
+        "sp_a4_finale2": 58,
+        "sp_a4_finale3": 59,
+        "sp_a4_finale4": 60,
+
+        "mp_coop_start":   61,
+        "mp_coop_lobby_2": 62,
+
+        "mp_coop_doors":         63,
+        "mp_coop_race_2":        64,
+        "mp_coop_laser_2":       65,
+        "mp_coop_rat_maze":      66,
+        "mp_coop_laser_crusher": 67,
+        "mp_coop_teambts":       68,
+
+        "mp_coop_fling_3":           69,
+        "mp_coop_infinifling_train": 70,
+        "mp_coop_come_along":        71,
+        "mp_coop_fling_1":           72,
+        "mp_coop_catapult_1":        73,
+        "mp_coop_multifling_1":      74,
+        "mp_coop_fling_crushers":    75,
+        "mp_coop_fan":               76,
+
+        "mp_coop_wall_intro":          77,
+        "mp_coop_wall_2":              78,
+        "mp_coop_catapult_wall_intro": 79,
+        "mp_coop_wall_block":          80,
+        "mp_coop_catapult_2":          81,
+        "mp_coop_turret_walls":        82,
+        "mp_coop_turret_ball":         83,
+        "mp_coop_wall_5":              84,
+
+        "mp_coop_tbeam_redirect":      85,
+        "mp_coop_tbeam_drill":         86,
+        "mp_coop_tbeam_catch_grind_1": 87,
+        "mp_coop_tbeam_laser_1":       88,
+        "mp_coop_tbeam_polarity":      89,
+        "mp_coop_tbeam_polarity2":     90,
+        "mp_coop_tbeam_polarity3":     91,
+        "mp_coop_tbeam_maze":          92,
+        "mp_coop_tbeam_end":           93,
+
+        "mp_coop_paint_come_along":     94,
+        "mp_coop_paint_redirect":       95,
+        "mp_coop_paint_bridge":         96,
+        "mp_coop_paint_walljumps":      97,
+        "mp_coop_paint_speed_flings":   98,
+        "mp_coop_paint_red_racer":      99,
+        "mp_coop_paint_speed_catch":    100,
+        "mp_coop_paint_longjump_intro": 101,
+
+        "mp_coop_seperation_1":     102,
+        "mp_coop_tripleaxis":       103,
+        "mp_coop_catapult_catch":   104,
+        "mp_coop_2paints_1bridge":  105,
+        "mp_coop_paint_conversion": 106,
+        "mp_coop_bridge_catch":     107,
+        "mp_coop_laser_tbeam":      108,
+        "mp_coop_paint_rat_maze":   109,
+        "mp_coop_paint_crazy_box":  110,
 }
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 3a7fa18..c34cbcf 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -75,7 +75,7 @@ const App: React.FC = () => {
 
   return (
     <>
-      <UploadRunDialog open={uploadRunDialog} onClose={() => setUploadRunDialog(false)} mapID={uploadRunDialogMapID} games={games} />
+      <UploadRunDialog token={token} open={uploadRunDialog} onClose={() => setUploadRunDialog(false)} games={games} />
       <Sidebar setToken={setToken} profile={profile} setProfile={setProfile} onUploadRun={() => setUploadRunDialog(true)} />
       <Routes>
         <Route path="/" element={<Homepage />} />
diff --git a/frontend/src/api/Api.tsx b/frontend/src/api/Api.tsx
index 6731cb3..0f0c4d3 100644
--- a/frontend/src/api/Api.tsx
+++ b/frontend/src/api/Api.tsx
@@ -3,8 +3,9 @@ import { delete_token, get_token } from './Auth';
 import { get_user, get_profile, post_profile } from './User';
 import { get_games, get_chapters, get_games_chapters, get_game_maps, get_search } from './Games';
 import { get_official_rankings, get_unofficial_rankings } from './Rankings';
-import { get_map_summary, get_map_leaderboard, get_map_discussions, get_map_discussion, post_map_discussion, post_map_discussion_comment, delete_map_discussion } from './Maps';
+import { get_map_summary, get_map_leaderboard, get_map_discussions, get_map_discussion, post_map_discussion, post_map_discussion_comment, delete_map_discussion, post_record } from './Maps';
 import { delete_map_summary, post_map_summary, put_map_image, put_map_summary } from './Mod';
+import { UploadRunContent } from '../types/Content';
 
 // add new api call function entries here
 // example usage: API.get_games();
@@ -34,6 +35,7 @@ export const API = {
 
   post_map_discussion: (token: string, map_id: string, content: MapDiscussionContent) => post_map_discussion(token, map_id, content),
   post_map_discussion_comment: (token: string, map_id: string, discussion_id: number, comment: string) => post_map_discussion_comment(token, map_id, discussion_id, comment),
+  post_record: (token: string, run: UploadRunContent) => post_record(token, run),
 
   delete_map_discussion: (token: string, map_id: string, discussion_id: number) => delete_map_discussion(token, map_id, discussion_id),
   // Mod
diff --git a/frontend/src/api/Maps.tsx b/frontend/src/api/Maps.tsx
index fbad78c..6bdc3e6 100644
--- a/frontend/src/api/Maps.tsx
+++ b/frontend/src/api/Maps.tsx
@@ -1,6 +1,6 @@
 import axios from "axios";
 import { url } from "./Api";
-import { MapDiscussionContent } from "../types/Content";
+import { MapDiscussionContent, UploadRunContent } from "../types/Content";
 import { MapSummary, MapLeaderboard, MapDiscussions, MapDiscussion } from "../types/Map";
 
 export const get_map_summary = async (map_id: string): Promise<MapSummary> => {
@@ -74,3 +74,27 @@ export const delete_map_discussion = async (token: string, map_id: string, discu
   });
   return response.data.success;
 };
+
+export const post_record = async (token: string, run: UploadRunContent): Promise<[string]> => {
+  if (run.partner_demo && run.partner_id) {
+    const response = await axios.postForm(url(`maps/${run.map_id}/record`), {
+      "host_demo": run.host_demo,
+      "partner_demo": run.partner_demo,
+      "partner_id": run.partner_id,
+    }, {
+      headers: {
+        "Authorization": token,
+      }
+    });
+    return response.data.message;
+  } else {
+    const response = await axios.postForm(url(`maps/${run.map_id}/record`), {
+      "host_demo": run.host_demo,
+    }, {
+      headers: {
+        "Authorization": token,
+      }
+    });
+    return response.data.message;
+  }
+};
diff --git a/frontend/src/components/UploadRunDialog.tsx b/frontend/src/components/UploadRunDialog.tsx
index fb146ba..08d4108 100644
--- a/frontend/src/components/UploadRunDialog.tsx
+++ b/frontend/src/components/UploadRunDialog.tsx
@@ -3,25 +3,26 @@ import { UploadRunContent } from '../types/Content';
 
 import '../css/UploadRunDialog.css';
 import { Game } from '../types/Game';
-import Games from '../pages/Games';
 import { Map } from '../types/Map';
 import { API } from '../api/Api';
+import { useNavigate } from 'react-router-dom';
 
 interface UploadRunDialogProps {
+  token?: string;
   open: boolean;
   onClose: () => void;
-  mapID?: number;
   games: Game[];
 }
 
-const UploadRunDialog: React.FC<UploadRunDialogProps> = ({ open, onClose, mapID, games }) => {
+const UploadRunDialog: React.FC<UploadRunDialogProps> = ({ token, open, onClose, games }) => {
+
+  const navigate = useNavigate();
 
   const [uploadRunContent, setUploadRunContent] = React.useState<UploadRunContent>({
     map_id: 0,
     host_demo: null,
     partner_demo: null,
     partner_id: undefined,
-    is_partner_orange: undefined,
   });
 
   const [currentMap, setCurrentMap] = React.useState<string>("");
@@ -56,8 +57,10 @@ const UploadRunDialog: React.FC<UploadRunDialogProps> = ({ open, onClose, mapID,
     const gameMaps = await API.get_game_maps(game_id);
     setSelectedGameMaps(gameMaps);
     setUploadRunContent({
-      ...uploadRunContent,
       map_id: gameMaps[0].id,
+      host_demo: null,
+      partner_demo: null,
+      partner_id: undefined,
     });
     _set_current_map(gameMaps[0].name);
     setSelectedGameID(parseInt(game_id) - 1);
@@ -65,6 +68,50 @@ const UploadRunDialog: React.FC<UploadRunDialogProps> = ({ open, onClose, mapID,
     setLoading(false);
   };
 
+  const _handle_file_change = async (e: React.ChangeEvent<HTMLInputElement>, host: boolean) => {
+    if (e.target.files) {
+      if (host) {
+        setUploadRunContent({
+          ...uploadRunContent,
+          host_demo: e.target.files[0],
+        });
+      } else {
+        setUploadRunContent({
+          ...uploadRunContent,
+          partner_demo: e.target.files[0],
+        });
+      }
+    }
+  };
+
+  const _upload_run = async () => {
+    if (token) {
+      if (games[selectedGameID].is_coop) {
+        if (uploadRunContent.host_demo === null) {
+          alert("You must select a host demo to upload.")
+          return
+        } else if (uploadRunContent.partner_demo === null) {
+          alert("You must select a partner demo to upload.")
+          return
+        } else if (uploadRunContent.partner_id === undefined) {
+          alert("You must specify your partner.")
+          return
+        }
+      } else {
+        if (uploadRunContent.host_demo === null) {
+          alert("You must select a demo to upload.")
+          return
+        }
+      }
+      if (window.confirm("Are you sure you want to submit this run to LPHUB?")) {
+        const message = await API.post_record(token, uploadRunContent);
+        alert(message);
+        navigate(0);
+        onClose();
+      }
+    }
+  };
+
   React.useEffect(() => {
     if (open) {
     _handle_game_select("1", "Portal 2 - Singleplayer"); // a different approach?.
@@ -105,23 +152,28 @@ const UploadRunDialog: React.FC<UploadRunDialogProps> = ({ open, onClose, mapID,
                     <div>
                       <div id='dropdown2' className={dropdown2Vis ? "upload-run-dropdown" : "upload-run-dropdown hidden"}>
                         {selectedGameMaps && selectedGameMaps.map((gameMap) => (
-                          <div onClick={() => { setUploadRunContent({...uploadRunContent, map_id: parseInt(gameMap.name)}); _set_current_map(gameMap.name); _handle_dropdowns(2); }} key={gameMap.id}>{gameMap.name}</div>
+                          <div onClick={() => { setUploadRunContent({...uploadRunContent, map_id: gameMap.id}); _set_current_map(gameMap.name); _handle_dropdowns(2); }} key={gameMap.id}>{gameMap.name}</div>
                         ))}
                       </div>
                     </div>
                     <span>Host Demo</span>
-                    <input type="file" name="host_demo" id="host_demo" accept=".dem" />
+                    <input type="file" name="host_demo" id="host_demo" accept=".dem" onChange={(e) => _handle_file_change(e, true)} />
                     {
                       games[selectedGameID].is_coop &&
                       (
                         <>
                           <span>Partner Demo</span>
-                          <input type="file" name="partner_demo" id="partner_demo" accept=".dem" />
+                          <input type="file" name="partner_demo" id="partner_demo" accept=".dem" onChange={(e) => _handle_file_change(e, false)} />
+                          <span>Partner ID</span>
+                          <input type="text" name="partner_id" id="partner_id" onChange={(e) => setUploadRunContent({
+                            ...uploadRunContent,
+                            partner_id: e.target.value,
+                          })} />
                         </>
                       )
                     }
                     <div className='upload-run-buttons-container'>
-                      <button onClick={() => onClose()}>Submit</button>
+                      <button onClick={_upload_run}>Submit</button>
                       <button onClick={() => onClose()}>Cancel</button>
                     </div>
                   </div>
diff --git a/frontend/src/types/Content.tsx b/frontend/src/types/Content.tsx
index 5733f1f..e6e0cb1 100644
--- a/frontend/src/types/Content.tsx
+++ b/frontend/src/types/Content.tsx
@@ -22,5 +22,4 @@ export interface UploadRunContent {
   host_demo: File | null;
   partner_demo: File | null;
   partner_id?: string;
-  is_partner_orange?: boolean;
 };