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);
                        }
                }


                if ($total_size > $Conf{MaxArchiveSize}) {
                        $cont .= eval( q{ ${h2(Error)}});
                        $cont .= "Selected backups exceed max archive size.";
                } 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, status
                                        ) VALUES (
                                                (SELECT last_value FROM archive_id_seq), ?, ?
                                        )
                                });

                                $sth->execute($backup_id, 'ok');

                                $dbh->commit();

                                $cont .= qq{
                                        Archived following backups:
                                } . join(",", @selected_backup_ids) . qq{
                                        <br/>with following message:
                                        <div style="border: 1px solid #e0e0e0">
                                } . $In{'note'} . qq{
                                        </div>
                                };
                        }
                        $dbh->commit();
                }
        }

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

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

1;
1	dpavlin	4	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	dpavlin	53	my $dsn = $Conf{SearchDSN};
10			my $db_user = $Conf{SearchUser} \|\| '';
11	dpavlin	4
12	dpavlin	53	sub action() {
13			my $cont = "";
14			my $title;
15			my $subtitle;
16			my @files;
17
18	iklaric	137	my $dbh = DBI->connect($dsn, $db_user, "", { RaiseError => 1, AutoCommit => 0 } );
19	dpavlin	53
20			BackupPC::CGI::Lib::NewRequest();
21	iklaric	121	# $cont = Dumper(%In);
22	dpavlin	53	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	dpavlin	4
31			EOF
32
33	iklaric	121	$cont .= "Backups that have not been archived:<br>";
34	dpavlin	53	$cont .= BackupPC::SearchLib::displayBackupsGrid();
35	dpavlin	4
36	dpavlin	53	} else {
37	dpavlin	4
38	dpavlin	145	my @selected_backup_ids;
39
40	iklaric	144	my $total_size = 0;
41
42	iklaric	147	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	iklaric	121	}
48			}
49	dpavlin	53
50	dpavlin	145
51			if ($total_size > $Conf{MaxArchiveSize}) {
52	iklaric	144	$cont .= eval( q{ ${h2(Error)}});
53	dpavlin	145	$cont .= "Selected backups exceed max archive size.";
54			} else {
55	dpavlin	53
56	iklaric	148	# create new archive
57			my $sth = $dbh->prepare(q{
58			INSERT INTO archive (
59			id,
60			dvd_nr,
61			note,
62			username,
63			date
64			) VALUES (
65			nextVal('archive_id_seq'),
66			nextVal('dvd_nr'),
67			?,
68			?,
69			NOW()
70			)
71			});
72	iklaric	146
73	iklaric	148	# FIXME insert user here
74			$sth->execute($In{'note'}, 'dummy_user');
75
76	dpavlin	145	foreach my $backup_id (@selected_backup_ids) {
77	dpavlin	53
78	dpavlin	145	# link backups with archive
79			my $sth = $dbh->prepare(q{
80			INSERT INTO archive_backup (
81			archive_id, backup_id, status
82			) VALUES (
83			(SELECT last_value FROM archive_id_seq), ?, ?
84			)
85			});
86
87			$sth->execute($backup_id, 'ok');
88
89			$dbh->commit();
90
91			$cont .= qq{
92			Archived following backups:
93			} . join(",", @selected_backup_ids) . qq{
94			<br/>with following message:
95			<div style="border: 1px solid #e0e0e0">
96			} . $In{'note'} . qq{
97			</div>
98			};
99	iklaric	144	}
100	iklaric	146	$dbh->commit();
101	iklaric	121	}
102	dpavlin	4	}
103	dpavlin	145
104	dpavlin	53	Header($Lang->{Burn_media}, "", 1, "", $cont);
105	dpavlin	145
106	dpavlin	53	Trailer();
107			$dbh->disconnect();
108			}
109	dpavlin	4
110			1;