BackupPC/CGI/BurnMedia.pm

package BackupPC::CGI::BurnMedia;

use strict;
use BackupPC::CGI::Lib qw(:all);
use BackupPC::SearchLib;
use Data::Dumper;
use vars qw($Cgi %In $MyURL $User %Conf $TopDir $BinDir $bpc);

my $dsn = $Conf{SearchDSN};
my $db_user = $Conf{SearchUser} || '';

sub action() {
        my $cont = "";
        my $title;
        my $subtitle;
        my @files;

        my $dbh = DBI->connect($dsn, $db_user, "", { RaiseError => 1, AutoCommit => 0 } );

        BackupPC::CGI::Lib::NewRequest();
#       $cont = Dumper(%In);
        if (!defined($In{submitBurner})) {
                $title = eval(q{ ${h1($Lang->{Burn_media})}});
                $cont = Dumper(%In);
                $subtitle = eval(q{ ${h2($Lang->{Burn_media_select})}});
                $cont = <<EOF;

        $title
        $subtitle
        
EOF
              
                $cont .= "Backups that have not been archived:<br>";
                $cont .= BackupPC::SearchLib::displayBackupsGrid();
            
        } else {

                my @selected_backup_ids;

                my $total_size = 0;
                
                foreach my $key(keys(%In)) {
                        if ($key =~ m/^fcb([0-9]+)_([0-9]+)_([0-9]+)$/gi) {
                                my ($host_id, $backup_num, $backup_id) = ($1,$2,$3);
                                push @selected_backup_ids, $backup_id;
                                $total_size += BackupPC::SearchLib::getGzipSize($host_id, $backup_num);
                        }
                }

                # convert to Kb
                $total_size = $total_size / 1024;

                if ($total_size > $Conf{MaxArchiveSize}) {
                        $cont .= eval( q{ ${h2(Error)}});
                        $cont .= "Selected backups size $total_size exceed max archive size $Conf{MaxArchiveSize}.";
                } else {

                        # create new archive
                        my $sth = $dbh->prepare(q{
                                                        INSERT INTO archive (
                                                                id,
                                                                dvd_nr,
                                                                note,
                                                                username,
                                                                date
                                                        ) VALUES (
                                                                nextVal('archive_id_seq'),
                                                                nextVal('dvd_nr'),
                                                                ?,
                                                                ?,
                                                                NOW()
                                                        )
                                                });

                        # FIXME insert user here
                        $sth->execute($In{'note'}, 'dummy_user');

                        foreach my $backup_id (@selected_backup_ids) {

                                # link backups with archive
                                my $sth = $dbh->prepare(q{
                                        INSERT INTO archive_backup (
                                                archive_id, backup_id
                                        ) VALUES (
                                                (SELECT last_value FROM archive_id_seq), ?
                                        )
                                });

                                $sth->execute($backup_id);

                                $dbh->commit();

                        }

                        my ($dvd_nr) = $dbh->selectrow_array(qq{
                                select last_value from dvd_nr
                        });

                        $dvd_nr ||= 'error';

                        $dbh->commit();

                        $cont .= q{
                                Archived following backups:
                        } . join(", ", @selected_backup_ids) . q{
                                <br/>with total size of
                        <b>} . sprintf("%1.2f Mb", $total_size / 1024) . q{</b>
                                to media <b>} . $dvd_nr . q{</b>
                                with following message:
                                <div style="background-color: #e0e0e0; display: inline; padding: 2px;">
                        } . $In{'note'} . q{
                                </div>
                        };
                }
        }

        Header($Lang->{Burn_media}, "", 1, "", $cont);

        Trailer();
        $dbh->disconnect();
}

1;
1	package BackupPC::CGI::BurnMedia;
2
3	use strict;
4	use BackupPC::CGI::Lib qw(:all);
5	use BackupPC::SearchLib;
6	use Data::Dumper;
7	use vars qw($Cgi %In $MyURL $User %Conf $TopDir $BinDir $bpc);
8
9	my $dsn = $Conf{SearchDSN};
10	my $db_user = $Conf{SearchUser} \|\| '';
11
12	sub action() {
13	my $cont = "";
14	my $title;
15	my $subtitle;
16	my @files;
17
18	my $dbh = DBI->connect($dsn, $db_user, "", { RaiseError => 1, AutoCommit => 0 } );
19
20	BackupPC::CGI::Lib::NewRequest();
21	# $cont = Dumper(%In);
22	if (!defined($In{submitBurner})) {
23	$title = eval(q{ ${h1($Lang->{Burn_media})}});
24	$cont = Dumper(%In);
25	$subtitle = eval(q{ ${h2($Lang->{Burn_media_select})}});
26	$cont = <<EOF;
27
28	$title
29	$subtitle
30
31	EOF
32
33	$cont .= "Backups that have not been archived:<br>";
34	$cont .= BackupPC::SearchLib::displayBackupsGrid();
35
36	} else {
37
38	my @selected_backup_ids;
39
40	my $total_size = 0;
41
42	foreach my $key(keys(%In)) {
43	if ($key =~ m/^fcb([0-9]+)_([0-9]+)_([0-9]+)$/gi) {
44	my ($host_id, $backup_num, $backup_id) = ($1,$2,$3);
45	push @selected_backup_ids, $backup_id;
46	$total_size += BackupPC::SearchLib::getGzipSize($host_id, $backup_num);
47	}
48	}
49
50	# convert to Kb
51	$total_size = $total_size / 1024;
52
53	if ($total_size > $Conf{MaxArchiveSize}) {
54	$cont .= eval( q{ ${h2(Error)}});
55	$cont .= "Selected backups size $total_size exceed max archive size $Conf{MaxArchiveSize}.";
56	} else {
57
58	# create new archive
59	my $sth = $dbh->prepare(q{
60	INSERT INTO archive (
61	id,
62	dvd_nr,
63	note,
64	username,
65	date
66	) VALUES (
67	nextVal('archive_id_seq'),
68	nextVal('dvd_nr'),
69	?,
70	?,
71	NOW()
72	)
73	});
74
75	# FIXME insert user here
76	$sth->execute($In{'note'}, 'dummy_user');
77
78	foreach my $backup_id (@selected_backup_ids) {
79
80	# link backups with archive
81	my $sth = $dbh->prepare(q{
82	INSERT INTO archive_backup (
83	archive_id, backup_id
84	) VALUES (
85	(SELECT last_value FROM archive_id_seq), ?
86	)
87	});
88
89	$sth->execute($backup_id);
90
91	$dbh->commit();
92
93	}
94
95	my ($dvd_nr) = $dbh->selectrow_array(qq{
96	select last_value from dvd_nr
97	});
98
99	$dvd_nr \|\|= 'error';
100
101	$dbh->commit();
102
103	$cont .= q{
104	Archived following backups:
105	} . join(", ", @selected_backup_ids) . q{
106	<br/>with total size of
107	<b>} . sprintf("%1.2f Mb", $total_size / 1024) . q{</b>
108	to media <b>} . $dvd_nr . q{</b>
109	with following message:
110	<div style="background-color: #e0e0e0; display: inline; padding: 2px;">
111	} . $In{'note'} . q{
112	</div>
113	};
114	}
115	}
116
117	Header($Lang->{Burn_media}, "", 1, "", $cont);
118
119	Trailer();
120	$dbh->disconnect();
121	}
122
123	1;