identity_interface_graphql

var AdminIdentityGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "AdminIdentity",
	Description: "the administration identity",
	Fields: graphql.Fields{
		"UID": &graphql.Field{
			Type:        graphql.String,
			Description: "the unique ID of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.UID, nil
				}
				return nil, errors.New("can not cast UID object")
			},
		},
		"acceptConditionsAndPrivacy": &graphql.Field{
			Type:        graphql.Boolean,
			Description: "accept conditions and privacy",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.AcceptConditionsAndPrivacy, nil
				}
				return nil, errors.New("can not cast accept terms and conditions value")
			},
		},
		"active": &graphql.Field{
			Type:        graphql.Boolean,
			Description: "has activated the account through email",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Active, nil
				}
				return nil, errors.New("can not cast active value")
			},
		},
		"cleared": &graphql.Field{
			Type:        graphql.Boolean,
			Description: "has been cleared by an admin or automatically depending on the settings",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Cleared, nil
				}
				return nil, errors.New("can not cast cleared value")
			},
		},
		"blocked": &graphql.Field{
			Type:        graphql.Boolean,
			Description: "has been blocked by an admin",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Blocked, nil
				}
				return nil, errors.New("can not cast blocked value")
			},
		},
		"createdAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the creation date of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.CreatedAt, nil
				}
				return nil, errors.New("can not cast created at timestamp")
			},
		},
		"deletedAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the deletion date of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.DeletedAt, nil
				}
				return nil, errors.New("can not cast deleted at timestamp")
			},
		},
		"updatedAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the update date of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.UpdatedAt, nil
				}
				return nil, errors.New("can not cast updated at timestamp")
			},
		},
		"salutation": &graphql.Field{
			Type:        graphql.String,
			Description: "the salutation of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Salutation, nil
				}
				return nil, errors.New("can not cast salutation value")
			},
		},
		"firstName": &graphql.Field{
			Type:        graphql.String,
			Description: "the first name of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.FirstName, nil
				}
				return nil, errors.New("can not cast first name value")
			},
		},
		"lastName": &graphql.Field{
			Type:        graphql.String,
			Description: "the last name of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.LastName, nil
				}
				return nil, errors.New("can not cast last name value")
			},
		},
		"email": &graphql.Field{
			Type:        graphql.String,
			Description: "the email of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Email, nil
				}
				return nil, errors.New("can not cast email object")
			},
		},
		"backupEmail": &graphql.Field{
			Type:        graphql.Int,
			Description: "the backup email of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.BackupEmail, nil
				}
				return nil, errors.New("can not cast backup email object")
			},
		},
		"phone": &graphql.Field{
			Type:        graphql.String,
			Description: "the phone number of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Phone, nil
				}
				return nil, errors.New("can not cast phone object")
			},
		},
		"backupPhone": &graphql.Field{
			Type:        graphql.Int,
			Description: "the backup phone of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.BackupPhone, nil
				}
				return nil, errors.New("can not cast backup phone object")
			},
		},
	},
})

var ApiTokenGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "ApiToken",
	Description: "the API token of the identity",
	Fields: graphql.Fields{
		"UID": &graphql.Field{
			Type:        graphql.String,
			Description: "the unique ID of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityApiToken); ok {
					return obj.UID, nil
				}
				return nil, errors.New("can not cast api token UID")
			},
		},
		"createdAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the creation date of the api token",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityApiToken); ok {
					return obj.CreatedAt, nil
				}
				return nil, errors.New("can not cast api token creation date")
			},
		},
		"name": &graphql.Field{
			Type:        graphql.String,
			Description: "the name of the api token",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityApiToken); ok {
					return obj.Name, nil
				}
				return nil, errors.New("can not cast api token name")
			},
		},
		"token": &graphql.Field{
			Type:        graphql.String,
			Description: "the name of the api token",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityApiToken); ok {
					return obj.Token, nil
				}
				return nil, errors.New("can not cast api token")
			},
		},
		"expirationDate": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the expiration dat of the api token",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityApiToken); ok {
					return obj.ExpirationDate, nil
				}
				return nil, errors.New("can not cast api token expiration date")
			},
		},
	},
})

var ErrAgentFromContext = errors.New("can not extract user agent from context")

var ErrInvalidUid = errors.New("can not parse uid from arguments")

var ErrIpFromContext = errors.New("can not extract ip from context")

var ErrOriginFromContext = errors.New("can not extract origin from context")

var ErrUserIdFromContext = errors.New("can not get IDENTITY_UID from context")

var IdentitiesPaginationGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "Identities",
	Description: "An identities result object",
	Fields: graphql.Fields{
		"results": &graphql.Field{
			Type:        graphql.NewList(AdminIdentityGraphQlModel),
			Description: "list of identities",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*IdentitiesPaginationDTO); ok {
					return obj.Results, nil
				}
				return nil, errors.New("can not cast object")
			},
		},
		"amount": &graphql.Field{
			Type:        graphql.Int,
			Description: "the total amount of identities",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*IdentitiesPaginationDTO); ok {
					return obj.Amount, nil
				}
				return nil, errors.New("can not cast object")
			},
		},
	},
})

var IdentityGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "Identity",
	Description: "the identity",
	Fields: graphql.Fields{
		"UID": &graphql.Field{
			Type:        graphql.String,
			Description: "the unique ID of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.UID, nil
				}
				return nil, errors.New("can not cast UID object")
			},
		},
		"createdAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the creation date of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.CreatedAt, nil
				}
				return nil, errors.New("can not cast UID object")
			},
		},
		"salutation": &graphql.Field{
			Type:        graphql.String,
			Description: "the salutation of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Salutation, nil
				}
				return nil, errors.New("can not cast email object")
			},
		},
		"firstName": &graphql.Field{
			Type:        graphql.String,
			Description: "the first name of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.FirstName, nil
				}
				return nil, errors.New("can not cast email object")
			},
		},
		"lastName": &graphql.Field{
			Type:        graphql.String,
			Description: "the last name of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.LastName, nil
				}
				return nil, errors.New("can not cast email object")
			},
		},
		"email": &graphql.Field{
			Type:        graphql.String,
			Description: "the email of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Email, nil
				}
				return nil, errors.New("can not cast email object")
			},
		},
		"backupEmail": &graphql.Field{
			Type:        graphql.Int,
			Description: "the backup email of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.BackupEmail, nil
				}
				return nil, errors.New("can not cast backupEmail object")
			},
		},
		"phone": &graphql.Field{
			Type:        graphql.String,
			Description: "the phone number of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.Phone, nil
				}
				return nil, errors.New("can not cast phone object")
			},
		},
		"backupPhone": &graphql.Field{
			Type:        graphql.Int,
			Description: "the backup phone of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.Identity); ok {
					return obj.BackupPhone, nil
				}
				return nil, errors.New("can not cast backupPhone object")
			},
		},
	},
})

var IdentityMutationObject = graphql.NewInputObject(graphql.InputObjectConfig{
	Name: "IdentityMutationObject",
	Fields: graphql.InputObjectConfigFieldMap{
		"UID": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"salutation": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"firstName": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"lastName": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"email": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"backupEmail": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"phone": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
		"backupPhone": &graphql.InputObjectFieldConfig{
			Type: graphql.String,
		},
	},
})

var LoginAttemptGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "LoginAttempt",
	Description: "the login attempt of identities",
	Fields: graphql.Fields{
		"UID": &graphql.Field{
			Type:        graphql.String,
			Description: "the unique ID of the identity",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.UID, nil
				}
				return nil, errors.New("can not cast login attempt UID")
			},
		},
		"createdAt": &graphql.Field{
			Type:        graphql.DateTime,
			Description: "the creation date of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.CreatedAt, nil
				}
				return nil, errors.New("can not cast login attempt creation date")
			},
		},
		"email": &graphql.Field{
			Type:        graphql.String,
			Description: "the name of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.Email, nil
				}
				return nil, errors.New("can not cast login attempt email")
			},
		},
		"origin": &graphql.Field{
			Type:        graphql.String,
			Description: "the origin of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.Origin, nil
				}
				return nil, errors.New("can not cast login attempt origin")
			},
		},
		"userAgent": &graphql.Field{
			Type:        graphql.String,
			Description: "the user agent of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.UserAgent, nil
				}
				return nil, errors.New("can not cast login attempt user agent")
			},
		},
		"ip": &graphql.Field{
			Type:        graphql.String,
			Description: "the ip of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.IP, nil
				}
				return nil, errors.New("can not cast login attempt ip")
			},
		},
		"identityUID": &graphql.Field{
			Type:        graphql.String,
			Description: "the identity UID of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					return obj.IdentityUID, nil
				}
				return nil, errors.New("can not cast login attempt identity UID")
			},
		},
		"success": &graphql.Field{
			Type:        graphql.Boolean,
			Description: "the success of the login attempt",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*identity_models.IdentityLogin); ok {
					if obj.IdentityUID == nil {
						return false, nil
					}
					return *obj.IdentityUID != uuid.Nil, nil
				}
				return nil, errors.New("can not cast login attempt identity UID")
			},
		},
	},
})

var LoginAttemptsPaginationGraphQlModel = graphql.NewObject(graphql.ObjectConfig{
	Name:        "LoginAttemptsField",
	Description: "Login attempts pagination",
	Fields: graphql.Fields{
		"results": &graphql.Field{
			Type:        graphql.NewList(LoginAttemptGraphQlModel),
			Description: "list of login attempts",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*LoginAttemptsPaginationDTO); ok {
					return obj.Results, nil
				}
				return nil, errors.New("can not cast object")
			},
		},
		"amount": &graphql.Field{
			Type:        graphql.Int,
			Description: "the total amount of projects",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if obj, ok := p.Source.(*LoginAttemptsPaginationDTO); ok {
					return obj.Amount, nil
				}
				return nil, errors.New("can not cast object")
			},
		},
	},
})