step 13 : add rekap kehadiran homescreen

backend/graph/generated/generated.go

@@ -59,11 +59,20 @@ type ComplexityRoot struct {
 	}
 
 	Query struct {
-		QueryCheckDistance       func(childComplexity int, mStaffID string, mCompanyID string, currentLatitude string, currentLongitude string) int
-		QueryCheckTimeAttendance func(childComplexity int, mStaffID string, mCompanyID string, token string) int
-		SearchStaffByEmail       func(childComplexity int, email string) int
-		StaffGetByStaffID        func(childComplexity int, staffID string) int
-		StaffListBySearch        func(childComplexity int, search *string, page *int, maxPerPage *int) int
+		QueryCheckDistance            func(childComplexity int, mStaffID string, mCompanyID string, currentLatitude string, currentLongitude string) int
+		QueryCheckTimeAttendance      func(childComplexity int, mStaffID string, mCompanyID string, token string) int
+		QueryRekapKehadiranHomeScreen func(childComplexity int, mStaffID string, mCompanyID string, token string) int
+		SearchStaffByEmail            func(childComplexity int, email string) int
+		StaffGetByStaffID             func(childComplexity int, staffID string) int
+		StaffListBySearch             func(childComplexity int, search *string, page *int, maxPerPage *int) int
+	}
+
+	RekapKehadiranHomeScreen struct {
+		Kehadiran  func(childComplexity int) int
+		Lembur     func(childComplexity int) int
+		Message    func(childComplexity int) int
+		Status     func(childComplexity int) int
+		TidakHadir func(childComplexity int) int
 	}
 
 	Staff struct {
@@ -125,6 +134,7 @@ type QueryResolver interface {
 	StaffListBySearch(ctx context.Context, search *string, page *int, maxPerPage *int) ([]*model.Staff, error)
 	QueryCheckDistance(ctx context.Context, mStaffID string, mCompanyID string, currentLatitude string, currentLongitude string) (*model.TransAbsensiCheckDistanceResponse, error)
 	QueryCheckTimeAttendance(ctx context.Context, mStaffID string, mCompanyID string, token string) (*model.TransAbsensiCheckTimeAttendanceResponse, error)
+	QueryRekapKehadiranHomeScreen(ctx context.Context, mStaffID string, mCompanyID string, token string) (*model.RekapKehadiranHomeScreen, error)
 }
 
 type executableSchema struct {
@@ -232,6 +242,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Query.QueryCheckTimeAttendance(childComplexity, args["M_StaffID"].(string), args["M_CompanyID"].(string), args["token"].(string)), true
 
+	case "Query.queryRekapKehadiranHomeScreen":
+		if e.complexity.Query.QueryRekapKehadiranHomeScreen == nil {
+			break
+		}
+
+		args, err := ec.field_Query_queryRekapKehadiranHomeScreen_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Query.QueryRekapKehadiranHomeScreen(childComplexity, args["M_StaffID"].(string), args["M_CompanyID"].(string), args["token"].(string)), true
+
 	case "Query.searchStaffByEmail":
 		if e.complexity.Query.SearchStaffByEmail == nil {
 			break
@@ -268,6 +290,41 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Query.StaffListBySearch(childComplexity, args["search"].(*string), args["page"].(*int), args["maxPerPage"].(*int)), true
 
+	case "RekapKehadiranHomeScreen.kehadiran":
+		if e.complexity.RekapKehadiranHomeScreen.Kehadiran == nil {
+			break
+		}
+
+		return e.complexity.RekapKehadiranHomeScreen.Kehadiran(childComplexity), true
+
+	case "RekapKehadiranHomeScreen.lembur":
+		if e.complexity.RekapKehadiranHomeScreen.Lembur == nil {
+			break
+		}
+
+		return e.complexity.RekapKehadiranHomeScreen.Lembur(childComplexity), true
+
+	case "RekapKehadiranHomeScreen.message":
+		if e.complexity.RekapKehadiranHomeScreen.Message == nil {
+			break
+		}
+
+		return e.complexity.RekapKehadiranHomeScreen.Message(childComplexity), true
+
+	case "RekapKehadiranHomeScreen.status":
+		if e.complexity.RekapKehadiranHomeScreen.Status == nil {
+			break
+		}
+
+		return e.complexity.RekapKehadiranHomeScreen.Status(childComplexity), true
+
+	case "RekapKehadiranHomeScreen.tidak_hadir":
+		if e.complexity.RekapKehadiranHomeScreen.TidakHadir == nil {
+			break
+		}
+
+		return e.complexity.RekapKehadiranHomeScreen.TidakHadir(childComplexity), true
+
 	case "Staff.company_id":
 		if e.complexity.Staff.CompanyID == nil {
 			break
@@ -663,6 +720,15 @@ type TransAbsensiCheckTimeAttendanceResponse {
   is_absen_clock_out: String
 }
 
+# response home screen rekap kehadiran
+type RekapKehadiranHomeScreen {
+  status: String
+  message: String
+  kehadiran: String
+  tidak_hadir: String
+  lembur: String
+}
+
 # query 
 extend type Query {
   # untuk cek distance dengan fungsi distance_v2 di database
@@ -670,6 +736,9 @@ extend type Query {
 
   # untuk check waktu absen masuk dan pulang 
   queryCheckTimeAttendance(M_StaffID:String!, M_CompanyID:String!, token:String!) : TransAbsensiCheckTimeAttendanceResponse!
+
+  # untuk home screen rekap kehadiran
+  queryRekapKehadiranHomeScreen(M_StaffID:String!, M_CompanyID:String!, token:String!) : RekapKehadiranHomeScreen!
 }
 
 # mutation
@@ -981,6 +1050,39 @@ func (ec *executionContext) field_Query_queryCheckTimeAttendance_args(ctx contex
 	return args, nil
 }
 
+func (ec *executionContext) field_Query_queryRekapKehadiranHomeScreen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+	var err error
+	args := map[string]interface{}{}
+	var arg0 string
+	if tmp, ok := rawArgs["M_StaffID"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("M_StaffID"))
+		arg0, err = ec.unmarshalNString2string(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["M_StaffID"] = arg0
+	var arg1 string
+	if tmp, ok := rawArgs["M_CompanyID"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("M_CompanyID"))
+		arg1, err = ec.unmarshalNString2string(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["M_CompanyID"] = arg1
+	var arg2 string
+	if tmp, ok := rawArgs["token"]; ok {
+		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("token"))
+		arg2, err = ec.unmarshalNString2string(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["token"] = arg2
+	return args, nil
+}
+
 func (ec *executionContext) field_Query_searchStaffByEmail_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
@@ -1833,6 +1935,73 @@ func (ec *executionContext) fieldContext_Query_queryCheckTimeAttendance(ctx cont
 	return fc, nil
 }
 
+func (ec *executionContext) _Query_queryRekapKehadiranHomeScreen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Query_queryRekapKehadiranHomeScreen(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.Query().QueryRekapKehadiranHomeScreen(rctx, fc.Args["M_StaffID"].(string), fc.Args["M_CompanyID"].(string), fc.Args["token"].(string))
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*model.RekapKehadiranHomeScreen)
+	fc.Result = res
+	return ec.marshalNRekapKehadiranHomeScreen2ᚖcomᚗsismedikaᚗcomᚗabsensiᚋgraphᚋmodelᚐRekapKehadiranHomeScreen(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_Query_queryRekapKehadiranHomeScreen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "Query",
+		Field:      field,
+		IsMethod:   true,
+		IsResolver: true,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "status":
+				return ec.fieldContext_RekapKehadiranHomeScreen_status(ctx, field)
+			case "message":
+				return ec.fieldContext_RekapKehadiranHomeScreen_message(ctx, field)
+			case "kehadiran":
+				return ec.fieldContext_RekapKehadiranHomeScreen_kehadiran(ctx, field)
+			case "tidak_hadir":
+				return ec.fieldContext_RekapKehadiranHomeScreen_tidak_hadir(ctx, field)
+			case "lembur":
+				return ec.fieldContext_RekapKehadiranHomeScreen_lembur(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type RekapKehadiranHomeScreen", field.Name)
+		},
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			err = ec.Recover(ctx, r)
+			ec.Error(ctx, err)
+		}
+	}()
+	ctx = graphql.WithFieldContext(ctx, fc)
+	if fc.Args, err = ec.field_Query_queryRekapKehadiranHomeScreen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+		ec.Error(ctx, err)
+		return fc, err
+	}
+	return fc, nil
+}
+
 func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 	fc, err := ec.fieldContext_Query___type(ctx, field)
 	if err != nil {
@@ -1962,6 +2131,211 @@ func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, fie
 	return fc, nil
 }
 
+func (ec *executionContext) _RekapKehadiranHomeScreen_status(ctx context.Context, field graphql.CollectedField, obj *model.RekapKehadiranHomeScreen) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_RekapKehadiranHomeScreen_status(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Status, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	fc.Result = res
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_RekapKehadiranHomeScreen_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "RekapKehadiranHomeScreen",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _RekapKehadiranHomeScreen_message(ctx context.Context, field graphql.CollectedField, obj *model.RekapKehadiranHomeScreen) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_RekapKehadiranHomeScreen_message(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Message, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	fc.Result = res
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_RekapKehadiranHomeScreen_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "RekapKehadiranHomeScreen",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _RekapKehadiranHomeScreen_kehadiran(ctx context.Context, field graphql.CollectedField, obj *model.RekapKehadiranHomeScreen) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_RekapKehadiranHomeScreen_kehadiran(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Kehadiran, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	fc.Result = res
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_RekapKehadiranHomeScreen_kehadiran(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "RekapKehadiranHomeScreen",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _RekapKehadiranHomeScreen_tidak_hadir(ctx context.Context, field graphql.CollectedField, obj *model.RekapKehadiranHomeScreen) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_RekapKehadiranHomeScreen_tidak_hadir(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.TidakHadir, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	fc.Result = res
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_RekapKehadiranHomeScreen_tidak_hadir(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "RekapKehadiranHomeScreen",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _RekapKehadiranHomeScreen_lembur(ctx context.Context, field graphql.CollectedField, obj *model.RekapKehadiranHomeScreen) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_RekapKehadiranHomeScreen_lembur(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Lembur, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	fc.Result = res
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_RekapKehadiranHomeScreen_lembur(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "RekapKehadiranHomeScreen",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
 func (ec *executionContext) _Staff_staff_id(ctx context.Context, field graphql.CollectedField, obj *model.Staff) (ret graphql.Marshaler) {
 	fc, err := ec.fieldContext_Staff_staff_id(ctx, field)
 	if err != nil {
@@ -5268,6 +5642,28 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
 					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
 			}
 
+			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
+		case "queryRekapKehadiranHomeScreen":
+			field := field
+
+			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+				defer func() {
+					if r := recover(); r != nil {
+						ec.Error(ctx, ec.Recover(ctx, r))
+					}
+				}()
+				res = ec._Query_queryRekapKehadiranHomeScreen(ctx, field)
+				if res == graphql.Null {
+					atomic.AddUint32(&fs.Invalids, 1)
+				}
+				return res
+			}
+
+			rrm := func(ctx context.Context) graphql.Marshaler {
+				return ec.OperationContext.RootResolverMiddleware(ctx,
+					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+			}
+
 			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
 		case "__type":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
@@ -5300,6 +5696,50 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
 	return out
 }
 
+var rekapKehadiranHomeScreenImplementors = []string{"RekapKehadiranHomeScreen"}
+
+func (ec *executionContext) _RekapKehadiranHomeScreen(ctx context.Context, sel ast.SelectionSet, obj *model.RekapKehadiranHomeScreen) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, rekapKehadiranHomeScreenImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("RekapKehadiranHomeScreen")
+		case "status":
+			out.Values[i] = ec._RekapKehadiranHomeScreen_status(ctx, field, obj)
+		case "message":
+			out.Values[i] = ec._RekapKehadiranHomeScreen_message(ctx, field, obj)
+		case "kehadiran":
+			out.Values[i] = ec._RekapKehadiranHomeScreen_kehadiran(ctx, field, obj)
+		case "tidak_hadir":
+			out.Values[i] = ec._RekapKehadiranHomeScreen_tidak_hadir(ctx, field, obj)
+		case "lembur":
+			out.Values[i] = ec._RekapKehadiranHomeScreen_lembur(ctx, field, obj)
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
 var staffImplementors = []string{"Staff"}
 
 func (ec *executionContext) _Staff(ctx context.Context, sel ast.SelectionSet, obj *model.Staff) graphql.Marshaler {
@@ -5920,6 +6360,20 @@ func (ec *executionContext) marshalNLogoutResponse2ᚖcomᚗsismedikaᚗcomᚗab
 	return ec._LogoutResponse(ctx, sel, v)
 }
 
+func (ec *executionContext) marshalNRekapKehadiranHomeScreen2comᚗsismedikaᚗcomᚗabsensiᚋgraphᚋmodelᚐRekapKehadiranHomeScreen(ctx context.Context, sel ast.SelectionSet, v model.RekapKehadiranHomeScreen) graphql.Marshaler {
+	return ec._RekapKehadiranHomeScreen(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNRekapKehadiranHomeScreen2ᚖcomᚗsismedikaᚗcomᚗabsensiᚋgraphᚋmodelᚐRekapKehadiranHomeScreen(ctx context.Context, sel ast.SelectionSet, v *model.RekapKehadiranHomeScreen) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._RekapKehadiranHomeScreen(ctx, sel, v)
+}
+
 func (ec *executionContext) marshalNStaff2comᚗsismedikaᚗcomᚗabsensiᚋgraphᚋmodelᚐStaff(ctx context.Context, sel ast.SelectionSet, v model.Staff) graphql.Marshaler {
 	return ec._Staff(ctx, sel, &v)
 }