mutations

Documentation

Index

• Variables

Variables

var AddAccessMutation = &graphql.Field{
	Type:        types.AccessType,
	Description: "Add Access",
	Args: graphql.FieldConfigArgument{
		"idModule": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idRole": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"access": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.AccessInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		module, role, access, accessBson, err := models.AccessAddToBson(params.Args["idModule"],
			params.Args["idRole"], params.Args["access"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		if err := services.AddAccess(module.Id, role.Id, *accessBson); err != nil {
			return nil, err
		}
		return *access, nil
	},
}

var AddModuleMutation = &graphql.Field{
	Type:        types.ModuleType,
	Description: "Add Module",
	Args: graphql.FieldConfigArgument{
		"module": &graphql.ArgumentConfig{
			Type: types.ModuleInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}

		module, moduleBson, err := models.ModuleToBson(params.Args["module"])

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}

		err = services.AddModule(*moduleBson)
		if err != nil {
			return nil, err
		}
		return *module, err
	},
}

var AddOperation2ViewMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Add Operation to View",
	Args: graphql.FieldConfigArgument{
		"idView": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idOperation": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		idView, _ := params.Args["idView"].(string)
		idv, _ := primitive.ObjectIDFromHex(idView)
		idOperation, _ := params.Args["idOperation"].(string)
		ido, _ := primitive.ObjectIDFromHex(idOperation)
		err := services.AddOperation2View(idv, ido)

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		return true, nil
	},
}

var AddOperationMutation = &graphql.Field{
	Type:        types.OperationType,
	Description: "Add Operation",
	Args: graphql.FieldConfigArgument{
		"operation": &graphql.ArgumentConfig{
			Type: types.OperationInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		oper, operBson, err := models.OperationAddToBson(params.Args["operation"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		err = services.AddOperation(*operBson)
		if err != nil {
			return nil, err
		}
		return *oper, err
	},
}

var AddRole2UserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Add Role to User",
	Args: graphql.FieldConfigArgument{
		"idUser": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idRole": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		idUser, _ := params.Args["idUser"].(string)
		idu, _ := primitive.ObjectIDFromHex(idUser)
		idRole, _ := params.Args["idRole"].(string)
		idr, _ := primitive.ObjectIDFromHex(idRole)
		bol, err := services.AddRole2User(idu, idr)

		if bol == false {
			return nil, err
		}
		result, err := services.GetUserById(idu)
		if err != nil {
			return nil, err
		}
		return *result, err
	},
}

var AddRoleMutation = &graphql.Field{
	Type:        types.RoleType,
	Description: "Add View",
	Args: graphql.FieldConfigArgument{
		"idModule": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"role": &graphql.ArgumentConfig{
			Type: types.RoleInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		module, role, roleBson, err := models.RoleAddToBson(params.Args["idModule"], params.Args["role"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		err = services.AddRole(module.Id, *roleBson)
		if err != nil {
			return nil, err
		}
		return *role, err
	},
}

var AddUserGenericMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Add User",
	Args: graphql.FieldConfigArgument{
		"userGeneric": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.UserGenericInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		id, userBson, err := models.UserGenericToBson(params.Args["userGeneric"])

		if err != nil {
			return nil, err
		}

		err = services.AddUser(*userBson)
		if err != nil {
			return nil, err
		}
		userGeneric, err := services.GetUserById(*id)
		if err != nil {
			return nil, err
		}
		return *userGeneric, nil
	},
}

var AddUserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Add User",
	Args: graphql.FieldConfigArgument{
		"user": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.UserInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		user, userBson, err := models.UserToBson(params.Args["user"])

		if err != nil {
			return nil, err
		}

		err = services.AddUser(*userBson)
		if err != nil {
			return nil, err
		}
		return *user, err
	},
}

var AddViewMutation = &graphql.Field{
	Type:        types.ViewType,
	Description: "Add View",
	Args: graphql.FieldConfigArgument{
		"idModule": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"view": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.ViewInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}

		module, view, viewBson, err := models.ViewToBson(params.Args["idModule"], params.Args["view"])

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}

		err = services.AddView(module.Id, *viewBson)
		if err != nil {
			return nil, err
		}
		return *view, nil
	},
}

var RefreshPasswordUserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Refresh Password to default dni",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		id, _ := params.Args["id"].(string)
		idu, _ := primitive.ObjectIDFromHex(id)
		user, err := services.RefreshPasswordUser(idu)

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		return *user, nil
	},
}

var RemoveAccessMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove Access",
	Args: graphql.FieldConfigArgument{
		"idRole": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idAccess": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		idRole, _ := params.Args["idRole"].(string)
		idr, _ := primitive.ObjectIDFromHex(idRole)
		idAccess, _ := params.Args["idAccess"].(string)
		ida, _ := primitive.ObjectIDFromHex(idAccess)
		bol, err := services.RemoveAccess(idr, ida)
		defer secServices.AddOperationAudit(params, "", "", err)
		return bol, err
	},
}

var RemoveModuleMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove Module",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		id, _ := params.Args["id"].(string)
		idm, _ := primitive.ObjectIDFromHex(id)
		bol, err := services.RemoveModule(idm)

		defer secServices.AddOperationAudit(params, "", "", err)
		return bol, err
	},
}

var RemoveOperationMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove Operation",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		id, _ := params.Args["id"].(string)
		ido, _ := primitive.ObjectIDFromHex(id)
		bol, err := services.RemoveOperation(ido)
		defer secServices.AddOperationAudit(params, "", "", err)
		return bol, err
	},
}

var RemoveOperationOfViewMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove Operation of view",
	Args: graphql.FieldConfigArgument{
		"idView": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idOperation": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		idView, _ := params.Args["idView"].(string)
		idv, _ := primitive.ObjectIDFromHex(idView)
		idOperation, _ := params.Args["idOperation"].(string)
		ido, _ := primitive.ObjectIDFromHex(idOperation)
		bol, err := services.RemoveOperation2View(idv, ido)

		defer secServices.AddOperationAudit(params, "", "", err)
		return bol, err
	},
}

var RemoveRole2UserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Remove Role Of User",
	Args: graphql.FieldConfigArgument{
		"idUser": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idRole": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		idUser, _ := params.Args["idUser"].(string)
		idu, _ := primitive.ObjectIDFromHex(idUser)
		idRole, _ := params.Args["idRole"].(string)
		idr, _ := primitive.ObjectIDFromHex(idRole)
		bol, err := services.RemoveRole2User(idu, idr)

		if bol == false {
			return nil, err
		}
		result, err := services.GetUserById(idu)
		if err != nil {
			return nil, err
		}
		return *result, err
	},
}

var RemoveRoleMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove Role",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		id, _ := params.Args["id"].(string)
		idr, _ := primitive.ObjectIDFromHex(id)
		bol, err := services.RemoveRole(idr)

		defer secServices.AddOperationAudit(params, "", "", err)
		return bol, err
	},
}

var RemoveUserMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove User",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		id, _ := params.Args["id"].(string)
		idu, _ := primitive.ObjectIDFromHex(id)
		bol, err := services.RemoveUser(idu)

		return bol, err
	},
}

var RemoveViewMutation = &graphql.Field{
	Type:        graphql.Boolean,
	Description: "Remove View",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		id, _ := params.Args["id"].(string)
		idv, _ := primitive.ObjectIDFromHex(id)

		bol, err := services.GetViewinAccess(idv)

		defer secServices.AddOperationAudit(params, "", "", err)
		if bol {
			return false, err
		}

		bol, err = services.RemoveView(idv)
		return bol, err
	},
}

var UpdateAccessMutation = &graphql.Field{
	Type:        types.AccessType,
	Description: "Update Access",
	Args: graphql.FieldConfigArgument{
		"idRole": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"idAccess": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"access": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.AccessInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		idR, idA, idV, order, position, err := models.AccessUpdateToBson(params.Args["idRole"], params.Args["idAccess"], params.Args["access"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		err = services.UpdateAccess(idR, idA, idV, order, position)
		if err != nil {
			return nil, err
		}
		access, err := services.GetAccess(idA)
		if err != nil {
			return nil, err
		}
		return *access, nil
	},
}

var UpdateModuleMutation = &graphql.Field{
	Type:        types.ModuleType,
	Description: "Update Module",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"module": &graphql.ArgumentConfig{
			Type: types.ModuleInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}

		module, moduleBson, err := models.ModuleUpdateToBson(params.Args["id"], params.Args["module"])

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}

		err = services.UpdateModule(module.Id, *moduleBson)
		if err != nil {
			return nil, err
		}

		result, err := services.GetModule(module.Id)
		if err != nil {
			return nil, err
		}
		return *result, err
	},
}

var UpdateOperationMutation = &graphql.Field{
	Type:        types.OperationType,
	Description: "Update Operation",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"operation": &graphql.ArgumentConfig{
			Type: types.OperationInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		id, oper, err := models.OperationUpdateToBson(params.Args["id"], params.Args["operation"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		err = services.UpdateOperation(*id, *oper)
		if err != nil {
			return nil, err
		}
		operNew, err := services.GetOperationByID(*id)
		if err != nil {
			return nil, err
		}
		return *operNew, err
	},
}

var UpdatePasswordUserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Update Password of User",
	Args: graphql.FieldConfigArgument{
		"password": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.String),
		},
		"newPassword": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.String),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		user := params.Context.Value("current").(ms.Values).Get("currentUser").(interface{})
		id := user.(services.UserTkn).Id
		idu, _ := primitive.ObjectIDFromHex(id)
		password, _ := params.Args["password"].(string)
		newPassword, _ := params.Args["newPassword"].(string)
		u, err := services.UpdatePasswordUser(idu, password, newPassword)

		if err != nil {
			return nil, err
		}
		return *u, err
	},
}

var UpdateRoleMutation = &graphql.Field{
	Type:        types.RoleType,
	Description: "Update Role",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"role": &graphql.ArgumentConfig{
			Type: types.RoleInputType,
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {
		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}
		role, err := models.RoleUpdateToBson(params.Args["id"], params.Args["role"])
		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}
		err = services.UpdateRole(role.Id, role.Name, role.Description)
		if err != nil {
			return nil, err
		}
		return *role, err
	},
}

var UpdateUserMutation = &graphql.Field{
	Type:        types.UserType,
	Description: "Update User",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"user": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.UserInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		user, userBson, err := models.UserUpdateToBson(params.Args["id"], params.Args["user"])

		if err != nil {
			return nil, err
		}

		err = services.UpdateUser(user.Id, *userBson)
		if err != nil {
			return nil, err
		}

		result, err := services.GetUserById(user.Id)
		if err != nil {
			return nil, err
		}
		return *result, err
	},
}

var UpdateViewMutation = &graphql.Field{
	Type:        types.ViewType,
	Description: "Update View",
	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(graphql.ID),
		},
		"view": &graphql.ArgumentConfig{
			Type: graphql.NewNonNull(types.ViewInputType),
		},
	},
	Resolve: func(params graphql.ResolveParams) (interface{}, error) {

		if errPerm := secServices.ValidatePermissionToOperation(params); errPerm != nil {
			return nil, errPerm
		}

		view, err := models.ViewUpdateToBson(params.Args["id"], params.Args["view"])

		defer secServices.AddOperationAudit(params, "", "", err)
		if err != nil {
			return nil, err
		}

		err = services.UpdateView(view.Id, view.Name, view.Description, view.Url, view.Icon)
		if err != nil {
			return nil, err
		}
		return *view, err
	},
}