[Google+ Portable SDK .NET] Recuperar amigos de los circulos (V)

En esta quinta entrega vamos a ver cómo recuperar la lista de los amigos incluidos en nuestros círculos realizando una petición LIST al recurso PEOPLE de Google Plus. Para ello vamos a necesitar el token de acceso obtenido en  3ª entrega, y a continuación, hacer una petición HTTP GET a la url

https://www.googleapis.com/plus/v1/people/<id_usuario>/people/<coleccion>

donde <id_usuario> representa el id de cuenta Google Plus o si queremos hacer referencia a nuestra propia cuenta, podemos usar el literal “me“, y <coleccion> debe contener el literal “visible“.

Esta url debe incluir los siguientes parámetros en el query string

access_token: token de acceso recuperado en la 3ª entrega.

maxResult: (opcional) Número de amigos a recuperar por página. Su valor debe estar en el rango 1-100.

fields: (opcional) permite configurar los campos que queremos recuperar.

etag,items,kind,nextPageToken,selfLink,title,totalItems

orderBy: (opcional) campo por el que queremos ordenar

pageToken: (opcional) este campo permite acceder a la siguiente página de resultados. Cuando obtenemos la primera página, unos de los campos que recuperamos en el “nextPageToken“, el cual nos permitirá acceder a la siguiente página.

Recordamos, que también podéis hacer pruebas directamente desde la web de google plus.

Vamos a recordar la hoja de ruta para esta serie de artículos

1. Crear aplicación Google +

2. Obtener código de autorización

3. Obtener Token de acceso

4. Obtener información del perfil

5. Amigos en los círculos (actual)

6. Buscar Amigos

7. Obtener las publicaciones del muro

En el método “ObtenerAmigosAsync” de la clase “smpGooglePlusApi” se ha incluido toda la lógica necesaria para recuperar la lista de amigos incluidos en los círculos (con accesibilidad pública)

        public async Task<BusquedaUsuarios> ObtenerAmigosAsync(string token, string idUsuario = "me", string tokenPagina = "", string coleccion = "visible", int numResultadosPagina = 100, string campos = "")
        {
            BusquedaUsuarios resultadoBusqueda = new BusquedaUsuarios();
            StringBuilder cadUrl = new StringBuilder();
            if (string.IsNullOrEmpty(token))
                throw new ArgumentException("token");

            if (string.IsNullOrEmpty(idUsuario))
                idUsuario = "me";

            if (string.IsNullOrEmpty(coleccion))
                coleccion = "visible";

            if (numResultadosPagina > 100)
                throw new ArgumentException("numResultadosPagina maximo 100");

            HttpClient cliente = new HttpClient();

            cadUrl.AppendFormat(Declaraciones.URL_PEOPLE_LIST, idUsuario.UrlEncode(), coleccion.UrlEncode());
            cadUrl.AppendFormat("?access_token={0}&maxResults={1}", token.UrlEncode(), numResultadosPagina.ToString().UrlEncode());

            if (!string.IsNullOrEmpty(tokenPagina))
                cadUrl.AppendFormat("&pageToken={0}", tokenPagina.UrlEncode());

            if (!string.IsNullOrEmpty(campos))
                cadUrl.AppendFormat("&fields={0}", campos.UrlEncode());

            HttpResponseMessage respuestaHttp = await cliente.SendAsync(new HttpRequestMessage(HttpMethod.Get, cadUrl.ToString())).ConfigureAwait(false);
            RespuestaGooglePlus respuestaGooglePlus = await UtilidadesGenerales.ProcesarRespuestaAsync(respuestaHttp);

            if (respuestaGooglePlus.Estado == EstadoGooglePlus.Correcto)
            {
                if (!string.IsNullOrEmpty(respuestaGooglePlus.ContenidoRespuesta))
                {
                    JObject resultado = JObject.Parse(respuestaGooglePlus.ContenidoRespuesta);
                    resultadoBusqueda.nextPageToken = (resultado["nextPageToken"] != null ? resultado["nextPageToken"].ToString() : string.Empty);
                    resultadoBusqueda.etag = (resultado["etag"] != null ? resultado["etag"].ToString() : string.Empty);
                    resultadoBusqueda.title = (resultado["title"] != null ? resultado["title"].ToString() : string.Empty);
                    resultadoBusqueda.kind = (resultado["kind"] != null ? resultado["kind"].ToString() : string.Empty);

                    int totalReg = 0;
                    if (resultado["totalItems"] != null)
                    {
                        if (int.TryParse(resultado["totalItems"].ToString(), out totalReg))
                        {
                            resultadoBusqueda.totalItems = totalReg;
                        }
                    }

                    if (resultado["items"] != null)
                    {
                        JArray arrayResultados = JArray.Parse(resultado["items"].ToString());
                        if (arrayResultados != null)
                        {
                            foreach (JObject item in arrayResultados)
                            {
                                InfoPerfil reg = ParsearPerfilUsuario(item);
                                resultadoBusqueda.items.Add(reg);
                            }
                        }
                    }
                }
            }

            return resultadoBusqueda;
        }

en el cual realizamos las siguiente operaciones:

1. Comprobamos que los valores de entrada son correctos: token, idusuario, numRegistrosPagina…

2. Creamos la url según lo explicado al principio de este artículo.

3. Utilizamos la libreria Http Client para hacer una petición HTTP GET a la url anterior.

4. Si la respuesta ha sido correcta, usamos la librería json.net para parsear la cadena JSON (de la respuesta HTTP) a un objeto del tipo  “BusquedaUsuarios

    public class BusquedaUsuarios
    {
        public List<InfoPerfil> items { get; set; }
        public string kind { get; set; }
        public string etag { get; set; }
        public string title { get; set; }
        public string nextPageToken { get; set; }
        public int totalItems { get; set; }

        public BusquedaUsuarios()
        {
            items = new List<InfoPerfil>();
        }

    }

donde vamos a destacar el campo “nextPageToken“, el cual nos permitirá acceder a la siguiente página de resultados y la colección “items“, la cual es del tipo InfoPerfil (explicada en la 4ª entrega dedicada a recuperar el perfil de un usuario). Como podemos observar en el código, hemos usado el método JArray.Parse para convertir una colección en formato JSON a un array net, y por cada elemento del array llamamos al método “ParsearPerfilUsuario” para así obtener un objeto del tipo InfoPerfil.

En la siguiente imagen, se puede ver el aspecto del ejemplo para WPF

googleplus_parte5_demowpf

en la cual el listado de amigos es mostrado mediante un ListBox, con su ItemTemplate redefinido

        <local:ConversorImagen x:Key="ConversorImagen"></local:ConversorImagen>
        <Style x:Key="ListaUsuarios" TargetType="ListBox">
            <Setter Property="ItemTemplate">
                <Setter.Value>
                    <DataTemplate>
                        <Border>
                            <Grid>
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="50"></ColumnDefinition>
                                    <ColumnDefinition Width="Auto"></ColumnDefinition>
                                </Grid.ColumnDefinitions>
                                <Image Source="{Binding Path=image.url,Converter={StaticResource ConversorImagen}}" Grid.Column="0"></Image>
                                <TextBlock Grid.Column="1" Text="{Binding Path=displayName}"></TextBlock>
                            </Grid>
                        </Border>
                    </DataTemplate>
                </Setter.Value>
            </Setter>
        </Style>
...
<ListBox Name="lstResultadoAmigos" Grid.Row="1" ItemsSource="{Binding}" Style="{StaticResource ListaUsuarios}"></ListBox>

para mostrar el campo “displayname” e “image.rul” (el binding es realizado asignando la propiedad DataContext a la propiedad “items” de un objeto del tipo BusquedaUsuarios.

        private async void btnBuscarAmigosCirculos_Click(object sender, RoutedEventArgs e)
        {
            await RefrescarTokenAcceso();

            smpGooglePlusApi googleApi = new smpGooglePlusApi();
            BusquedaUsuarios listaBusqueda = await googleApi.ObtenerAmigosAsync(txtToken.Text, tbIdUsuario.Text);
            if ((listaBusqueda != null) && (listaBusqueda.items != null) && (listaBusqueda.items.Count > 0))
            {
                lstResultadoAmigos.DataContext = listaBusqueda.items;
                if (!string.IsNullOrEmpty(listaBusqueda.nextPageToken))
                {
                    btnSiguienteBuscarAmigos.Tag = listaBusqueda.nextPageToken;
                }

            }
        }

En el siguiente enlace podéis descargar el código de ejemplo.