CPAN::Groonga

 NAME

Quiq::Json - Operationen auf JSON Code

=head1 BASE CLASS

L<Quiq::Object>

=cut

# -----------------------------------------------------------------------------

package Quiq::Json;
use base q

e JSON ();

# -----------------------------------------------------------------------------

=head1 METHODS

=head2 Klassenmethoden

=head3 pretty() - Verschönere JSON Code

=head4 Synopsis

  $json 

->pretty($file);
  $json = $class->pretty($jsonIn);

=head4 Arguments

=over 4

=item $file

(String) Datei mit JSON Code, der verschönert werden soll

=item $jsonIn

(String) JSON Code, der verschö

Quiq::Json::Code - Erzeuge JSON-Code in Perl

=head1 BASE CLASS

L<Quiq::Hash>

=head1 SYNOPSIS

=head2 Klasse laden und Objekt instantiieren

  use Quiq::Json::Code;
  
  my $j = Quiq::Json::Code->

new;

=head2 JSON-Objekt via object()

  $json = $j->object(
      pi => 3.14159,
      str => 'Hello world!',
      bool => \'true',
      obj => $j->object(
          id => 4711,
          name => '

],
      },
      min: undefined,
  }

Bei der Methode $j->L<object|"object() - Erzeuge Code für JSON-Objekt">()

=over 2

=item *

bleibt die Reihenfolge der Schlüssel/Wert-Paare erhalten

=item *

te definieren

Hover-Texte können ohne Events nicht dynamisch berechnet werden,
da Plotly.js nur JSON-serialisierare Strukturkomponenten besitzt und
keine Funktionsattribute vorgesehen sind. Das Trac

se base qw/Quiq::Hash/;

use v5.10;
use strict;
use warnings;

our $VERSION = '1.232';

use Quiq::Json::Code;
use Quiq::Template;

# -------------------------------------------------------------------

= 4;
    my $zeroLineColor = '#d0d0d0';

    # Instantiiere Objekt zum Erzeugen von JSON-Code
    my $j = Quiq::Json::Code->new;

    # Traces

    push my @traces,$j->o(
        type => 'scatter',
  

aScript> - Generierung von JavaScript-Code

=item *

L<Quiq::Json> - Operationen auf JSON Code

=item *

L<Quiq::Json::Code> - Erzeuge JSON-Code in Perl

=item *

L<Quiq::LaTeX::Code> - Generator für

se base qw/Quiq::Hash/;

use v5.10;
use strict;
use warnings;

our $VERSION = '1.232';

use Quiq::Json::Code;
use Quiq::Array;
use Quiq::Template;

# --------------------------------------------------

    # Defaultwerte

    $title //= $parameter;

    # Konfiguration erzeugen

    my $j = Quiq::Json::Code->new;

    my @dataSets = $j->o(
        type => 'line',
        label => $parameter,
     

iq::Option;
use Quiq::Debug;
use Quiq::Hash;
use Quiq::Path;
use Quiq::Record;
use Quiq::Url;
use JSON ();

# -----------------------------------------------------------------------------

=head1 METH

im Falle von GET oder im Body des Requests
im Falle von POST.

=back

=head4 Returns

Dekodiertes JSON in UTF-8 als Perl-Hash

=head4 Description

Grundlegende Methode, über die sämtliche Interaktio

/);

    # Wir wollen die Antwort in JSON

    # my @keyVal = (action=>$action,formatversion=>2,format=>'json',@_);
    my @keyVal = (action=>$action,format=>'json',@_);

    # HTTP-Request erzeugen u

t;
use warnings;

our $VERSION = '1.232';

use Quiq::Html::Table::List;
use Quiq::Hash;
use Quiq::Json::Code;
use Quiq::Unindent;

# -------------------------------------------------------------------

der das DataTables-Objekt in JavaScript
instantiiert. Aufbau:

  jQuery('#ID').DataTable({
      <JSON-Code>,
      columns: [
          <Kolumnen-Definitionen>
      ]
  });

=cut

# ----------------

er info jsCode order
        orderClasses paging searchLabel zeroRecordsMsg/);

    my $j = Quiq::Json::Code->new;

    my @language;
    if ($emptyTableMsg) {
        push @language,emptyTable=>$empt

ash/;

use v5.10;
use strict;
use warnings;

our $VERSION = '1.232';

use Quiq::Assert;
use Quiq::Json::Code;

# -----------------------------------------------------------------------------

=head1 M

my $a = Quiq::Assert->new;
    $a->isNotNull($selector,-name=>'selector');

    # JSON-Generator
    my $j = Quiq::Json::Code->new;

    # Generiere JavaScript-Code

    return '$.contextMenu('.$j->o(

se v5.10;
use strict;
use warnings;
use utf8;

our $VERSION = '1.232';

use Quiq::Math;
use Quiq::Json::Code;
use Quiq::JavaScript;
use Quiq::Html::Table::Simple;
use Quiq::JQuery::Function;
use Quiq:

 my $xMax = undef;
    my $yMin = -1;
    my $yMax = 1;

    # JavaScript-Code

    my $j = Quiq::Json::Code->new;

    # * Namespace mit Datenstrukturen und Funktionen

    my $js = Quiq::JavaScript-

                      return;
                        }
                        // console.log(ed+JSON.stringify(ed,null,4));
                        $('#'+groupId+' '+'.diagram').each(function(j) {
 

age;
use base qw/Quiq::Hash/;

use v5.10;
use strict;
use warnings;

our $VERSION = '1.232';

use JSON ();
use Quiq::Debug;

# -------------------------------------------------------------------------

=head4 Synopsis

  $pag = $class->new($json);

=head4 Arguments

=over 4

=item $json

Body der HTTP-Antwort der getPage()-Operation. Der Body enthält
die JSON-Repräsentation der Seite.

=back

=he

---------------------------

sub new {
    my ($class,$json) = @_;

    return $class->SUPER::new(
        perl => $json? JSON::decode_json($json) : undef,
    );
}

# --------------------------------

r $VERSION = '1.232';

use LWP::UserAgent ();
use Quiq::Option;
use Quiq::Confluence::Markup;
use JSON ();
use Quiq::Confluence::Page;
use HTTP::Request::Common ();

# --------------------------------

    my $res = $self->send(
        POST => "rest/api/content",
        'application/json',
        JSON::encode_json({
            title => $title,
            type => 'page',
            space => {
 

tent/$pageId",
        PUT => "wiki/rest/api/content/$pageId",
        'application/json',
        JSON::encode_json({
            type => 'page',
            title => $title || $pag->title,
         

pe auf Klasse $class.

B<ACHTUNG>: Wir eleminieren skalare Referenzen. In einem JSON-Baum
(erzeugt von JSON::decode_json() können Referenzen \1 und \0 als
Repräsentation von true und false vorkommen

type eq 'SCALAR') {
        # Wir eleminieren skalare Referenzen. In einem JSON-Baum (erzeugt
        # von JSON::decode_json() können Referenzen \1 und \0 als
        # Repräsentation von true und