Merge pull request #3 from jkh675/satistic

Satistic impl

Author: normalid-awa

.gitignore

@@ -3,4 +3,5 @@ node_modules
 build
 ssl
 
-storage
+storage
+.vscode/.server-controller-port.log

.vscode/.server-controller-port.log

@@ -1,5 +1,5 @@
 {
-  "port": 13452,
-  "time": 1715412240136,
+  "port": 9145,
+  "time": 1716083435791,
   "version": "0.0.3"
 }

src/graphql/Shooter/type.ts

@@ -27,10 +27,10 @@ export const ShooterType = objectType({
 		t.list.field("scores", {
 			type: "Score",
 		});
-		t.list.field("rankings", {
+		t.nullable.list.field("rankings", {
 			type: "Ranking",
 		});
-		t.list.field("ratings", {
+		t.nullable.list.field("ratings", {
 			type: "Rating",
 		});
 	},

src/graphql/ShooterStatistic/index.ts

@@ -0,0 +1,2 @@
+export * from "./type";
+export * from "./query";

src/graphql/ShooterStatistic/query.ts

@@ -0,0 +1,16 @@
+import { extendType, nonNull } from "nexus";
+
+export const ShooterStatisticQuery = extendType({
+	type: "Query",
+	definition(t) {
+		t.field("shooterStatistic", {
+			type: "ShooterStatistic",
+			args: {
+				shooterId: nonNull("Int"),
+			},
+			resolve: (src, { shooterId }) => {
+				return { shooterId: shooterId };
+			},
+		});
+	},
+});

src/graphql/ShooterStatistic/type.ts

@@ -0,0 +1,171 @@
+import { objectType } from "nexus";
+
+export const ShooterStatistic = objectType({
+	name: "ShooterStatistic",
+	nonNullDefaults: {
+		input: true,
+		output: true,
+	},
+	definition(t) {
+		t.int("shooterId");
+		t.float("averageHitFactor", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_avg: {
+						hitFactor: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._avg.hitFactor || 0;
+			},
+		});
+		t.float("averageAccuracy", {
+			async resolve(src, args, ctx) {
+				return ( await ctx.prisma.score.aggregate({
+					_avg: {
+						accuracy: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._avg.accuracy || 0;
+			},
+		});
+		t.float("runCount", {
+			async resolve(src, args, ctx) {
+				return await ctx.prisma.score.count({
+					where: {
+						shooterId: src.shooterId,
+					},
+				});
+			},
+		});
+		t.float("finishedCount", {
+			async resolve(src, args, ctx) {
+				return await ctx.prisma.score.count({
+					where: {
+						state: "Scored",
+						shooterId: src.shooterId,
+					},
+				});
+			},
+		});
+		t.float("proErrorCount", {
+			async resolve(src, args, ctx) {
+				return(await ctx.prisma.score.aggregate({
+					_sum: {
+						proErrorCount: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.proErrorCount || 0;
+			},
+		});
+		t.float("dnfCount", {
+			async resolve(src, args, ctx) {
+				return await ctx.prisma.score.count({
+					where: {
+						state: "DidNotFinish",
+						shooterId: src.shooterId,
+					},
+				});
+			},
+		});
+		t.float("dqCount", {
+			async resolve(src, args, ctx) {
+				return await ctx.prisma.score.count({
+					where: {
+						state: "DQ",
+						shooterId: src.shooterId,
+					},
+				});
+			},
+		});
+		t.float("highestHitFactor", {
+			async resolve(src, args, ctx) {
+				return(await ctx.prisma.score.aggregate({
+					_max: {
+						hitFactor: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._max.hitFactor || 0;
+			},
+		});
+		t.float("highestAccuracy", {
+			async resolve(src, args, ctx) {
+				return(await ctx.prisma.score.aggregate({
+					_max: {
+						accuracy: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._max.accuracy || 0;
+			},
+		});
+		t.float("alphaCount", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_sum: {
+						alphas: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.alphas || 0;
+			},
+		});
+		t.float("charlieCount", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_sum: {
+						charlies: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.charlies || 0;
+			},
+		});
+		t.float("deltaCount", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_sum: {
+						deltas: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.deltas || 0;
+			},
+		});
+		t.float("missCount", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_sum: {
+						misses: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.misses || 0;
+			},
+		});
+		t.float("noShootCount", {
+			async resolve(src, args, ctx) {
+				return (await ctx.prisma.score.aggregate({
+					_sum: {
+						noshoots: true,
+					},
+					where: {
+						shooterId: src.shooterId,
+					},
+				}))._sum.noshoots || 0;
+			},
+		});
+	},
+});