#!/usr/bin/env perl                                 

my $criticalPriority = 3; # Minimum priority to check
my $criticalOffset = 2 * 60 * 60; # Time since update
my $fromAddr = 'root@example.com'; # Who mail should appear to come from
my $trackpath = "/tmp"; # Where to place tracking files                 
my @toAddrs = (); # You shouldn't change this.  Use command-line arguments.
my @queues; # You shouldn't change this.  Use command-line arguments.      
my $is_test = 0;                                                           
my $show_help = 0;                                                         

# Location of RT3's libs                                                   
use lib ("/opt/rt3/lib", "/opt/rt3/local/lib");                            

use strict;                                                                
use warnings;                                                              
use Getopt::Long;                                                          

GetOptions(                                                                
    'queue=s' => \@queues,                                                 
    'to=s' => \@toAddrs,                                                   
    'threshold=i' => \$criticalOffset,                                     
    'priority=i' => \$criticalPriority,                                    
    'test' => \$is_test,                                                   
    'help' => \$show_help,                                                 
);                                                                         

if ($show_help){                                                           
    print "\n$0 --threshold seconds --priority number [options]...         
        --threshold         # Number of seconds before next update         
        --priority          # Priority to check                            
        --to                # Who should get mailed, you can specify multiple
        --queue queuename   # Searches all by default, you can specify multiple
        --test              # Don't send mail, just print message              
        --help              # Show this screen                                 
        \n";                                                                   
    exit 1;                                                                    
}                                                                              


# Pull in the RT stuff                                                         
package RT;                                                                    
use RT::Interface::CLI qw(CleanEnv);                                           
use Mail::Mailer;                                                              
use POSIX qw(floor);                                                           
use Time::Piece;                                                               

# Clean our the environment                                                    
CleanEnv();                                                                    

# Load the RT configuration                                                    
RT::LoadConfig();                                                              

# Initialise RT                                                                
RT::Init();                                                                    

# If no queues given, get all enabled queues                                   
if(!@queues) {                                                                 
    my $queues = new RT::Queues($RT::SystemUser);                              
    $queues->LimitToEnabled();                                                 
    foreach my $queue (@{$queues->ItemsArrayRef()}) {                          
        push @queues, $queue->Name;                                            
    }                                                                          
}                                                                              

#Load tracking hash for repeat notification avoidance                          
my %th; # tracking hash                                                        
my @idlist; # used to strip tickets that are closed                            
my $trackfile = "$trackpath/NotifyTimed.$criticalPriority";                    
open(FH, "<$trackfile");                                                       
while(<FH>){                                                                   
    my @parts = split;                                                         
    $th{$parts[0]} = $parts[1];                                                
}                                                                              
close(FH);                                                                     

foreach my $queuename (@queues) {                                              
    my $queue = new RT::Queue($RT::SystemUser);                                
    $queue->Load($queuename);                                                  

    # Get hold of new, open, and stalled tickets only                          
    my $tickets = new RT::Tickets($RT::SystemUser);                            
    $tickets->LimitStatus(VALUE => 'open');                                    
    $tickets->LimitStatus(VALUE => 'new');                                     
    $tickets->LimitStatus(VALUE => 'stalled');                                 
    $tickets->LimitPriority(OPERATOR => '=', VALUE => $criticalPriority);      
    $tickets->LimitQueue(VALUE => $queue->Id);                                 

    while (my $ticket = $tickets->Next) {                                      
        my $ticketdt = Time::Piece->strptime($ticket->LastUpdated, "%Y-%m-%d %H:%M:%S");
        my $now = localtime;                                                            
        my $dt = $now - $criticalOffset;                                                
        my $will_notify = 0;                                                            

        if ($dt->epoch > $ticketdt->epoch){                                             
            my $minutes = floor(($now->epoch - $ticketdt->epoch) / 60);                 
            my $owner = $ticket->OwnerObj;                                              

            # Keep track of ids to strip old ones                                       
            push(@idlist, $ticket->Id);                                                 

            # Only notify once                                                          
            if (exists $th{$ticket->Id}){                                               
                if ($th{$ticket->Id} < $ticketdt->epoch){                               
                    $th{$ticket->Id} = $ticketdt->epoch;                                
                    $will_notify = 1;                                                   
                }                                                                       
            } else {                                                                    
                $th{$ticket->Id} = $ticketdt->epoch;                                    
                $will_notify = 1;                                                       
            }                                                                           

            # Prepare report                                                            
            my $mailmsg = '<html>                                                       
              <body>                                                                    
                <p>Ticket <a href="https://rt.wbsconnect.com/Ticket/Display.html?id='   
                .$ticket->Id.'">'.$ticket->Id.'</a> needs to be updated.</p>            
                <p>Subject: '.$ticket->Subject.'</p>                                    
                <p>Owner: '.$owner->RealName.'</p>                                      
                <p>Status: '.$ticket->Status.'</p>                                      
                <p>Priority: '.$ticket->Priority.'</p>                                  
                <p>Minutes since last update: '.$minutes.'</p>                          
              </body>                                                                   
            </html>';                                                                   

            # Send email, if this isn't a repeat or test                                
            next if not $will_notify;                                                   
            if ($is_test){
                print $mailmsg;
            } else {
                foreach (@toAddrs){
                    my $mailer = Mail::Mailer->new;
                    $mailer->open({
                        'From'    => $fromAddr,
                        'To'      => $_,
                        'Subject' => "Update Required:  Priority "
                            .$ticket->Priority." ticket "
                            .$ticket->Id." needs to be updated",
                        'MIME-Version' => "1.0",
                        'Content-Type' => "text/html",

                    });
                    print $mailer $mailmsg;
                    $mailer->close();
                }
            }
        }
    }
}

# Strip old ids from tracking hash
my %nth; # New tracking hash
foreach(@idlist){
    $nth{$_} = $th{$_};
}

# Write tracking hash to file for future use
open(FH, ">$trackfile");
while((my $key, my $value) = each(%nth)){
    print FH $key, " ", $value, "\n";
}
close(FH);

# Disconnect before we finish off
$RT::Handle->Disconnect();
exit 0;

#!/usr/bin/env python
import string
from random import choice
from Crypto.Cipher import AES

EOD = '`%EofD%`' # This should be something that will not occur in strings

def genstring(length=16, chars=string.printable):
    return ''.join([choice(chars) for i in range(length)])

def encrypt(key, s):
    obj = AES.new(key)
    datalength = len(s) + len(EOD)
    if datalength < 16:
        saltlength = 16 - datalength
    else:
        saltlength = 16 - datalength % 16
    ss = ''.join([s, EOD, genstring(saltlength)])
    return obj.encrypt(ss)

def decrypt(key, s):
    obj = AES.new(key)
    ss = obj.decrypt(s)
    return ss.split(EOD)[0]

if __name__ == '__main__':
    for i in xrange(8, 20):
        s = genstring(i)
        key = genstring(32)
        print 'The key is', key
        print 'The string is', s, i
        cipher  = encrypt(key, s)
        print 'The encrypted string is', cipher
        print 'This decrypted string is', decrypt(key, cipher)

#!/usr/bin/env python
import binascii
import qaes # This is the wrapper for PyCrypto

key = "32 character key can be anything"

s = "Sensitive Data"
print "Unencrypted data:", s

es = qaes.encrypt(key, s)
print "Encrypted binary:", es

esb64 = binascii.b2a_base64(es)
print "Encrypted base64:", esb64

esbin = binascii.a2b_base64(esb64)
print "Back to binary:", esbin

ds = qaes.decrypt(key, esbin)
print "Decrypted data", ds

import binascii
import qaes
from django.db import models
from django.conf import settings

class AESEncryptedField(models.CharField):
    def save_form_data(self, instance, data):
        setattr(instance, self.name,
            binascii.b2a_base64(qaes.encrypt(settings.AESKEY, data)))
    def value_from_object(self, obj):
        return qaes.decrypt(settings.AESKEY,
            binascii.a2b_base64(getattr(obj, self.attname)))