Null pointer error when modifying status

On a platform jsf I want to modify only the state attribute of a table. For this I have implemented the following method so that everything that had nothing to do with the state remains as it is, without being modified, but, as there are no changes in the other attributes, a null pointer exception jumps out:

public void putState() {
     Peticion p = new Peticion();
    FacesContext context = FacesContext.getCurrentInstance();
    HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();
    p.setId(bean.getId());
    p.setNombre(bean.getNombre());
    p.setDescripcion(bean.getDescripcion());
    p.setDirDestino(bean.getDirdestino());
    p.setDirOrigen(bean.getDirorigen());
    p.setDnidest(bean.getDnidest());
    p.setEstado("enviando");
    p.setFechaentr(bean.getFechaentr());
    p.setNombre_empresa(request.getUserPrincipal().getName());
    p.setNombredest(bean.getNombredest());
    p.setPeso(bean.getPeso());

    target.register(PeticionWriter.class).path("{id}").resolveTemplate("id", bean.getId()).request()
            .put(Entity.entity(p, MediaType.APPLICATION_JSON));
}

Being the ClientBean:

package client;
import com.mycompany.pfinal2psegrupo2.entidades.GruposUsuarios;
import com.mycompany.pfinal2psegrupo2.entidades.Usuarios;
import jaas.UsuarioEJB;
import java.util.List;
import java.util.Map;


import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.enterprise.context.RequestScoped;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
import javax.faces.event.ComponentSystemEvent;
import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import json.UserReader;
import json.UserWriter;


@Named
@RequestScoped 

public class UserClientBean{
  @Inject

  UserBackingBean bean;

  Client client;
  String emailUsuario;
  String email;
  String confirmpassword;

  List<GruposUsuarios>listado;

  WebTarget target;
  WebTarget target2;


  @PersistenceContext
  private EntityManager em;
  @PostConstruct
  public void init() {

    client = ClientBuilder.newClient();

    target = client.target("http://localhost:8080/PFinal2PSEGrupo2/webresources/com.mycompany.pfinal2psegrupo2.entidades.gruposusuarios");
    target2 = client.target("http://localhost:8080/PFinal2PSEGrupo2/webresources/com.mycompany.pfinal2psegrupo2.entidades.usuarios");

  }
  @PreDestroy
  public void destroy() {
    client.close();
  }
  public Usuarios getUser(String email) {
    return target
        .register(UserReader.class)
        .path("{email}")
        .resolveTemplate("email", email)
        .request(MediaType.APPLICATION_JSON)
        .get(Usuarios.class);
  }

public Usuarios[] getUsers() {
    return target.request().get(Usuarios[].class);
}
public GruposUsuarios findByNombreGrupo(String nombregrupo) {
    TypedQuery<GruposUsuarios> query = em.createNamedQuery("GruposUsuarios.findByNombregrupo", GruposUsuarios.class);
    query.setParameter("nombregrupo", nombregrupo);
    GruposUsuarios group = null;
    try {
        listado=query.getResultList();
        group = query.getSingleResult();
    } catch (Exception e) {
}
return group;
}

public void setGroups(List<GruposUsuarios>listado){
    this.listado=listado;
}
public List<GruposUsuarios>getGroups(){

  findByNombreGrupo("empresa");

  return listado;
}



public void putUser() {
 FacesContext context = FacesContext.getCurrentInstance();
    HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();

     Usuarios u = new Usuarios();
        u.setNombre(bean.getNombre());
        u.setApellidos(bean.getApellidos());
        u.setFechanac(bean.getFechanac());
        u.setEmail(request.getUserPrincipal().getName());
        u.setMovil(bean.getMovil());
        u.setMedio(bean.getMedio());
        u.setLocalidad(bean.getLocalidad());
        u.setDni(bean.getDni());
        u.setPassword(bean.getPassword());

     target.register(UserWriter.class).path("{email}").
     resolveTemplate("email", request.getUserPrincipal()).request()
     .put(Entity.entity(u,MediaType.APPLICATION_JSON));
 }

 public String getconfirmPassword() {
    return confirmpassword;
}

public void setconfirmPassword(String confirmPassword) {
    this.confirmpassword = confirmPassword;
}

public void deleteUser() {
    target2.path("{email}")
            .resolveTemplate("email", bean.getEmail())
            .request()
            .delete();
}

public void deleteGroup() {
    target.path("{email}")
            .resolveTemplate("email", bean.getEmail())
            .request()
            .delete();
}

public void EliminarRegistro() {

    deleteGroup();
    deleteUser();

}
}

And the BackingBean

package client;
import java.io.Serializable;

import javax.enterprise.context.SessionScoped;
import javax.inject.Named;

@Named
@SessionScoped

public class UserBackingBean implements Serializable{

String nombre;
String email;
String password;
String fechanac;
String nombregrupo;
String apellidos;
String localidad;
String dni;
String medio;
String movil;


public String getMedio() {
    return medio;
}

public void setMedio(String medio) {
    this.medio = medio;
}

public String getLocalidad() {
    return localidad;
}

public void setLocalidad(String localidad) {
    this.localidad = localidad;
}

public String getDni() {
    return dni;
}

public void setDni(String dni) {
    this.dni = dni;
}

public String getApellidos() {
    return apellidos;
}

public void setApellidos(String apellidos) {
    this.apellidos = apellidos;
}

public String getMovil() {
    return movil;
}

public void setMovil(String movil) {
    this.movil = movil;
}


public String getNombregrupo() {
    return nombregrupo;
}

public void setNombregrupo(String nombregrupo) {
    this.nombregrupo = nombregrupo;
}

public String getFechanac() {
    return fechanac;
}

public void setFechanac(String fechanac) {
    this.fechanac = fechanac;
}


public String getNombre() {
    return nombre;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}

}

Reader

package json;

import com.mycompany.pfinal2psegrupo2.entidades.Peticion; import java.io.IOException; import java.io.InputStream; import java.lang.annotation.Annotation; import java.lang.reflect.Type; import javax.json.Json; import javax.json.stream.JsonParser; import javax.ws.rs.Consumes; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.ext.MessageBodyReader; import javax.ws.rs.ext.Provider;

@Provider @Consumes (MediaType.APPLICATION_JSON) public class PeticionReader implements MessageBodyReader {

@Override
public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
  return Peticion.class.isAssignableFrom(type);
}


@Override
public Peticion readFrom(Class<Peticion> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
  Peticion peticion= new Peticion();
   JsonParser parser = Json.createParser(entityStream);
   while (parser.hasNext()) {
   switch (parser.next()) {
   case KEY_NAME:
   String key = parser.getString();
   parser.next();
   switch (key) {
         case "id":
            peticion.setId(parser.getInt());
             break;
         case "nombre":
          peticion.setNombre(parser.getString());
             break;

            case "descripcion":
                peticion.setDescripcion(parser.getString());
            break;
            case "peso":
               peticion.setPeso(parser.getString());
                break;
            case "dir_origen":
                peticion.setDirOrigen(parser.getString());
                 break;
            case "dir_destino":
               peticion.setDirDestino(parser.getString());
                break;
                case "dnidest":
               peticion.setDnidest(parser.getString());
                break;

                 case "estado":
               peticion.setEstado(parser.getString());
                break;

                 case "nombre_empresa":
               peticion.setNombre_empresa(parser.getString());
                break;

                    case "nombredest":
               peticion.setNombredest(parser.getString());
                break;

                  case "fechaentr":
               peticion.setFechaentr(parser.getString());
                break;

         default:
         break;
          }
         break;
         default:
         break;
        }
         }
          return peticion;
         }
}

Writer

package json; import com.mycompany.pfinal2psegrupo2.entidades.Peticion; import java.io.IOException; import java.io.OutputStream; import java.lang.annotation.Annotation; import java.lang.reflect.Type; import javax.json.Json; import javax.json.stream.JsonGenerator; import javax.ws.rs.Produces; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.ext.MessageBodyWriter; import javax.ws.rs.ext.Provider;

@Provider @Produces (MediaType.APPLICATION_JSON) public class RequestWriter implements MessageBodyWriter {

@Override
public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
    return Peticion.class.isAssignableFrom(type);
}

@Override
public long getSize(Peticion t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
   return -1;
}

@Override
public void writeTo(Peticion p, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    JsonGenerator gen = Json.createGenerator(entityStream);
    gen.writeStartObject()
   .write("id", p.getId())      
   .write("nombre", p.getNombre())
   .write("descripcion", p.getDescripcion())
   .write("peso", p.getPeso())
   .write("estado", p.getEstado())
   .write("dir_origen", p.getDirOrigen())
   .write("dir_destino", p.getDirDestino())
   .write("nombre_empresa", p.getNombre_empresa()) 
   .write("fechaentr", p.getFechaentr()) 
   .write("dnidest", p.getDnidest()) 
   .write("nombredest", p.getNombredest()) 

    .writeEnd();
    gen.flush();
}

}

Exceptions appear in the writer:

In the line of .write ("id", p.getId ())

and in the @Provider

Thanks in advance