Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

package DivBasicF::Test_GoogleCal;

use strict;
use DivBasicF::GoogleCal;

#use JSON;
#use Math::Round;

use constant VERSION => [ 1, "all" ];
### token to identify this file as a test module
### TEST_ID = "GoogleCal";

sub new {
	my $class = shift;
	my $self  = {};

	$self->{'ACCOUNTS'} = {
		't2d1@trash-mail.com' => 'h3ndf9456',
		't2d2@trash-mail.com' => 'j83m9dn85'
	};

	$self->{'USERS'}     = [ keys( %{ $self->{'ACCOUNTS'} } ) ];
	$self->{'PASSWORDS'} = [ values( %{ $self->{'ACCOUNTS'} } ) ];
	$self->{'CALENDARS'} = [];
	my @gc_new = [];
	for ( my $i = 0 ; $i < @{ $self->{'USERS'} } ; $i++ ) {
		push( @{ $self->{'CALENDARS'} }, "default" );  # default scheint hier die beste loesung zu sein
		push( @gc_new, "default" );              #"c$i");
		push( @gc_new, $self->{'USERS'}[$i] );
	}

	$self->{_cal} = DivBasicF::GoogleCal->new(@gc_new);
	
	$self->{json} = new JSON;

	bless( $self, $class );
	return ($self);
}
#########################################################################
sub auth {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] && $pars[1] ) {    # direkt mit Zugangsdaten einloggen
		$self->{_cal} = DivBasicF::GoogleCal->new( cal => $pars[0] );
		return $self->{_cal}->auth( $pars[0], $pars[1] );
	}
	else {
		return $self->{_cal}->auth( $self->{'USERS'}[ $pars[0] ], $self->{'PASSWORDS'}[ $pars[0] ] );
	}
}

#########################################################################
# transformiert das Datumsformat DD.MM.JJJJ zu JJJJ-MM-DD
sub parse_date {
	my $self = shift;
	my $date = shift;

	my ( $d, $m, $j ) = split( /\./, $date );
	$d = "0$d" if ( $d < 10 );
	$m = "0$m" if ( $m < 10 );
	return "$j-$m-$d";
}
#########################################################################
# wandelt ein Integer in das Zeit-Format hh:mm:ss um (muss zwischen 0 und 86400 liegen)
sub parse_time {
	my $self = shift;
	my $time = shift;

	my $h = int( $time / 3600 );
	$time = $time - $h * 3600;
	my $m = int( $time / 60 );
	$time = $time - $m * 60;
	my $s = int($time);
	$h = "0$h" if $h < 10;
	$m = "0$m" if $m < 10;
	$s = "00";    #$s = "0$s" if $s<10;
	return "$h:$m:$s";
}

################################################
################################################
sub run {
	my $self    = shift;
	my $area1   = shift;
	my $area2   = shift;
	my $dyndata = shift;

	my $testname = shift(@$area1); #print "tn $testname\n";
	
	# check version
	unless ( @$area2[0] eq VERSION->[0] and @$area2[1] eq VERSION->[1] ) {
		return ( 10, "Version mismatch!" );
	}

	# map the functions
	if ( $testname eq "test_create_and_delete" ) {
		my @ret = $self->test_00004( @$area1, $dyndata );
		return @ret;
	} elsif ( $testname eq "random") {
		return $self->test_random(@$area1, $dyndata);
	}

}

sub generate {
	my $self   = shift;
	my $params = shift;
	
	my $testname = @$params[0];
	
	if ( $testname eq "test_create_and_delete" ) {
		
			my $dyndata = {"title"=>"test_title_".(100000+int rand(899990)),
				"content"=>"test_content_".(100000+int rand(899990)),
				"place"=>"test_place_".(100000+int rand(899990))
			};

			return $self->{json}->encode($dyndata);
	} elsif ( $testname eq "random") {
		my $count = @$params[1];
		my $date = @$params[2];
		my $time = @$params[3];
		
		my $path = {
			"authentificate"	 => ["create"],
			"create" => ["check_exists"],
			"delete" => ["check_deleted"],
			"check_exists" => ["delete"],
			"check_deleted" => ["create"]
		};
		
		my $last = "authentificate";
		my $code = "$last;";
		
		while ($count > 0) {
			my $opts = $path->{$last};
			my $index = rand @$opts;
			my $next = @$opts[$index];
			
			$last = $next;
			
			$code.=$next.";";
			
			$count--;
		}
		
		$code .= "check_results;";
		
		my $r = round(	rand (@{$self->{'USERS'}}-1));
		my $participants = round(	rand (@{$self->{'USERS'}}-1)); # -1 as the 'main' user is always in
		$participants = 1 if $participants==0;
		
		my @particps = [$self->{'USERS'}[$r] ];
		while ($participants>0) {
			my $p = round(	rand (@{$self->{'USERS'}}-1));
			
		}
		
		my $dyndata = {
				"title" 	=> 	"test_title_".(100000+int rand(899990)),
				"content" 	=>	"test_content_".(100000+int rand(899990)),
				"place"		=>	"test_place_".(100000+int rand(899990)),
				"date"		=> 	$date,
				"time"		=> 	$time,
				"user" 		=>	$r,
				"participants"=>	$self->{'USERS'}[$r],
				"code" 		=>	 $self->add_self($code),
				"added_entries" => [],
				"deleted_entries" => [],
				"results" => []
		};
		my $dd = $self->{json}->encode($dyndata);
#		print $dd."\n";
		return $dd;
	}
}

sub find_entry {
	my ( $self, $calendar, $timerange, $cal_idr ) = @_;
	my $entr = $self->{_cal}->find_entry( $calendar, $timerange );

	my $entry_to_ret = 0;

	foreach my $en (@$entr) {
		if ( $en->{'IDR'} eq $cal_idr ) {
			$entry_to_ret = $en;
		}
	}
	
	return $entry_to_ret;
}

sub test_00001 {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Ungueltiger Login");
	}

	my $oldcal = $self->{_cal};    # den alten Kalender zwischenspeichern

	$self->{_cal} = DivBasicF::GoogleCal->new( cal => "lghe\@a576345.com" );

	my $ret = $self->auth( "lghe\@a576345.com", "deuukln8" );

	$self->{_cal} = $oldcal;       # und wiederherstellen

	if ( !$ret ) {
		return ( 0, "SUCCESS" );
	}
	else {
		return ( 1000, "ERROR: Keine richtige Anzeige eines ungueltigen Logins!". __LINE__ );
	}

	#  return(10,"Could not execute Test because of ...");
	#  return(11,"Could not execute Test because of ...");
	#  return(12,"Could not execute Test because of ...");
	#  return(1000,"ERROR: ...");
	#  return(1001,"ERROR: ...");
}
#########################################################################
sub test_00002 {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Login");
	}

	my $ret = $self->auth(0);

	if ($ret) {
		return ( 0, "SUCCESS" );
	}
	else {
		return ( 1001, "ERROR: Konnte sich nicht einloggen!" . __LINE__ );
	}
}
#########################################################################
sub test_00003 {
	my $self = shift;
	my @pars = @_;
	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Ob die Kalenderliste zurueckgegeben wird.");
	}

	# Annahme: der Login von letzten Test hat funktioniert
	if ( $self->{_cal}->calendarlist() ) {
		return ( 0, "SUCCESS" );
	}
	else {
		return ( 1002,"ERROR: Konnte die Kalenderliste nicht bekommen!" . __LINE__ );
	}
}
#########################################################################
sub test_00004 {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Kombination von Anlegen und Loeschen von Eintraegen.");
	}

	my ( $date, $time, $dyndata ) = @pars;
	$date = $self->parse_date($date);

	my $time2 = $self->parse_time( $time + 3600 );    # fuer die Endzeit (eine Stunde spaeter)
	$time = $self->parse_time($time);
	my $start = $date . "T" . $time;
	my $end   = $date . "T" . $time2;

	my $user    = 0;

	my $dyndata = $self->{json}->decode($dyndata);
	my $title   = $dyndata->{"title"};
	my $content = $dyndata->{"content"};
	my $place   = $dyndata->{"place"};

	$self->auth($user) or return ( 1001,"ERROR: konnte sich nicht als User $self->{'USERS'}[$user] einloggen". __LINE__ );

	#einen Eintrag anlegen
	my $result = $self->{_cal}->create_entry( $self->{'CALENDARS'}[$user],
		$title, $content, $place, $start, $end, 0, $self->{'USERS'}[$user] );

	#diesen Eintrag finden (sollte klappen)
	$date =~ s/-//g;    #alle '-' entfernen, um das Format fuer die Suchanfrage zu bekommen
	my $entr = $self->find_entry($self->{'CALENDARS'}[$user],"$date-$date",$result);

	return ( 1005,"ERROR: konnte den angelegten Eintrag nicht finden!" . __LINE__ ) unless $entr;    #(@$entr);

	#den gefundenen Eintrag loeschen
	$self->{_cal}->delete_entry( $entr, 0 );               #delete without notification

	#diesen Eintrag finden (sollte nicht klappen)
	my $entr2 = $self->find_entry( $self->{'CALENDARS'}[$user], "$date-$date", $result);

	return ( 1006, "ERROR: Der Eintrag, der gerade geloescht werden sollte, wurde immer noch gefunden". __LINE__ ) if $entr2;

	return ( 0, "SUCCESS" );

}
#########################################################################
sub test_00005 {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Kombination von Anlegen und Loeschen von Eintraegen mit einem weiteren Teilnehmer.");
	}

	# als User 1 einloggen
	$self->auth(0) or return ( 1001,"ERROR: konnte sich nicht als User 1 einloggen" . __LINE__ );

	# einen Eintrag mit User 2 als Teilnehmer anlegen
	$self->{_cal}->create_entry(
		"default",               "test_00005",
		"content of test_00005", "place of test_00005",
		"2008-12-17T10:00:00",   "2008-12-17T11:00:00",
		1,                       "t2d1\@trash-mail.com",
		"t2d2\@trash-mail.com"
	);

	# diesen Eintrag selber finden
	my $entr = $self->{_cal}->find_entry( "default", "20081217-20081217" );
	return ( 1005,"ERROR: konnte den angelegten Eintrag nicht finden!" . __LINE__ )  unless (@$entr);

	# sich als User 2 einloggen
	$self->auth(1) or return ( 1001, "ERROR: konnte sich nicht als User 2 einloggen" . __LINE__ );

	# den Eintrag finden
	my $entr2 = $self->{_cal}->find_entry( "default", "20081217-20081217" );
	return ( 1005, "ERROR: konnte den angelegten Eintrag nicht finden!" . __LINE__ ) unless (@$entr2);

	# wieder als User 1 einloggen
	$self->auth(0)  or return ( 1001, "ERROR: konnte sich nicht als User 1 einloggen" . __LINE__ );

	# den vorher gefundenen Eintrag loeschen
	$self->{_cal}->delete_entry( $entr->[0], 0 );

	# versuche, diesen Eintrag zu finden (sollte NICHT funktionieren)
	my $entr3 = $self->{_cal}->find_entry( "default", "20081216-20081216" );
	return ( 1006, "ERROR: Der Eintrag, der gerade geloescht werden sollte, wurde immer noch gefunden" . __LINE__ ) if (@$entr3);

	# als User 2 einloggen
	$self->auth(1) or return ( 1001, "ERROR: konnte sich nicht als User 2 einloggen" );

	# versuche, diesen Eintrag zu finden (sollte NICHT funktionieren)
	my $entr4 = $self->{_cal}->find_entry( "default", "20081217-20081217" );
	return ( 1006, "ERROR: Der Eintrag, der gerade geloescht werden sollte, wurde immer noch gefunden" . __LINE__ ) if (@$entr4);

	return ( 0, "SUCCESS" );
}
#########################################################################
sub test_00006 {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Titel und Beschreibung eines Eintrags aendern");
	}

	$self->auth(0)
	  or return ( 1001,
		"ERROR: konnte sich nicht als User 1 einloggen" . __LINE__ );

	$self->{_cal}->create_entry(
		"c1",                    "test_00006",
		"content of test_00006", "place of test_00006",
		"2008-12-18T10:00:00",   "2008-12-18T11:00:00",
		0,                       "t2d1\@trash-mail.com"
	);

	my $entr = $self->{_cal}->find_entry( "c1", "20081218-20081218" );
	return ( 1005,"ERROR: konnte den angelegten Eintrag nicht finden!" . __LINE__ )  unless (@$entr);

	my $title     = $entr->[0]->{'TITLE'};
	my $nexttitle = "random title";

	my $ch = { 'T' => $nexttitle };
	$self->{_cal}->change_entry( @$entr, $ch );
	$self->{_cal}->update_entry(@$entr);

	my $entr2 = $self->{_cal}->find_entry( "c1", "20081218-20081218" );
	return ( 1005,"ERROR: konnte den angelegten Eintrag nicht finden!" . __LINE__ ) unless (@$entr2);

	( $entr2->[0]->{'TITLE'} == $nexttitle ) or return ( 1007, "ERROR: der Title des Eintrags wurde nicht geaendert!" );

	$self->{_cal}->delete_entry(@$entr2);

	return ( 0, "SUCCESS" );
}
#########################################################################
sub add_self {
	my $self = shift;
	my $str = shift;
	my $ret = "";
	foreach my $o (split(/\;/,$str)) {
			if ($o eq "check_results") {
				$ret.="\@jdata=\$self->$o(\$jdata);";
			} elsif ($o) {
				$ret.="\$jdata=\$self->$o(\$jdata);";
			}
	}
	return $ret;
}

sub test_random {
	my $self = shift;
	my @pars = @_;

	if ( $pars[0] eq "___DESCRIPTION___" ) {
		return ("Kombination von Anlegen und Loeschen von Eintraegen.");
	}

	my ( $count, $date, $time, $jdata ) = @pars;

	my $dyndata = $self->{json}->decode($jdata);
	my $user	= $dyndata->{"user"};
	my $title   = $dyndata->{"title"};
	my $content = $dyndata->{"content"};
	my $place   = $dyndata->{"place"};
	my $code 	= $dyndata->{"code"};
	
	my @jdata;
	eval($code); # last code line must return "@jdata"
	return @jdata;
}

sub result_ok {
	my $self = shift;
	my $jdata = shift;
	my $data = $self->{json}->decode($jdata);
	push(@{$data->{"results"}}, [0, "SUCCESS"]);
	return $self->{json}->encode($data);
}

sub result_bad {
	my $self = shift;
	my $jdata = shift;
	my $result = shift;
	my $data = $self->{json}->decode($jdata);
	push(@{$data->{"results"}}, $result);
	return $self->{json}->encode($data);
}

sub check_results {
	my $self = shift;
	my $jdata = shift;
	my $data = $self->{json}->decode($jdata);
	my $results = $data->{"results"};

	foreach my $res (@$results) {
		if (@$res[0] != 0) {
			return @$res;
		}
	}
	
	return (0,"SUCCESS");
}

sub authentificate {
	my $self = shift;
	my $jdata = shift;
	
	my $data = $self->{json}->decode($jdata);
	
	if (! $self->auth($data->{"user"}) )  {
		return $self->result_bad($jdata,[1001,"ERROR: konnte sich nicht als User 1 einloggen" . __LINE__ ] );
	}
	
	return $self->result_ok($jdata);
}

sub create {
	my $self = shift;
	my $jdata = shift;
	
	my $data = $self->{json}->decode($jdata);
	my $date = $self->parse_date($data->{"date"});

	my $time2 = $self->parse_time( $data->{"time"} + 3600 );    # fuer die Endzeit (eine Stunde spaeter)
	my $time = $self->parse_time($data->{"time"});
	my $start = $date . "T" . $time;
	my $end   = $date . "T" . $time2;

	my $title   = $data->{"title"};
	my $content = $data->{"content"};
	my $place   = $data->{"place"};

	#einen Eintrag anlegen
	my $result = $self->{_cal}->create_entry( $self->{'CALENDARS'}[$data->{"user"}],
		$title, $content, $place, $start, $end, 0, $self->{'USERS'}[$data->{"user"}] );
		
	push( @{$data->{"added_entries"}}, $result);
	
	$jdata = $self->{json}->encode($data);
	
	return $self->result_ok($jdata);
}

sub check_exists {
	my $self = shift;
	my $jdata = shift;

	my $data = $self->{json}->decode($jdata);
#	my @added_entries = $data->{"added_entries"};
	my $date = $self->parse_date($data->{"date"});
	$date =~ s/-//g;    #alle '-' entfernen, um das Format fuer die Suchanfrage zu bekommen
	
	foreach my $entry (@{$data->{"added_entries"}}) {
		my $entr = $self->find_entry($self->{'CALENDARS'}[$data->{"user"}],"$date-$date",$entry);
		if (! $entr) {
			return $self->result_bad($jdata,[1005,"ERROR: konnte den angelegten Eintrag nicht finden!"]);
		}
	}
	return $self->result_ok($jdata);
}

sub delete {
	my $self = shift;
	my $jdata = shift;

	my $data = $self->{json}->decode($jdata);
	
	my $date = $self->parse_date($data->{"date"});
	$date =~ s/-//g;
	my $entry = shift @{$data->{"added_entries"}};
	my $entr = $self->find_entry($self->{'CALENDARS'}[$data->{"user"}],"$date-$date",$entry); #only search for the first entry, hence delete it
	$self->{_cal}->delete_entry( $entr, 0 );
	
	push(@{$data->{"deleted_entries"}},$entry);
	
	$jdata = $self->{json}->encode($data);
	return $self->result_ok($jdata);
}

sub check_deleted {
	my $self = shift;
	my $jdata = shift;

	my $data = $self->{json}->decode($jdata);
	my @deleted_entries = $data->{"deleted_entries"};
	my $date = $self->parse_date($data->{"date"});
	$date =~ s/-//g;    #alle '-' entfernen, um das Format fuer die Suchanfrage zu bekommen
	
	foreach my $entry (@deleted_entries) {
		my $entr = $self->find_entry($self->{'CALENDARS'}[$data->{"user"}],"$date-$date",$entry);
		if ($entr) {
			return $self->result_bad($jdata,[1006,"Der Eintrag, der gerade geloescht werden sollte, wurde immer noch gefunden"]);
		}
	}
	return $self->result_ok($jdata);
}

1;