root/trunk/licq/bin/licq.kicqconvert

#!/usr/bin/perl -w
#
# Author: Nathan "i am not y2k compliant" Benson
#  Email: phuzz@phactor.org
#    URL: http://www.phactor.org/
#   Date: 01.19.1900
#
###################################################################
#
# tested using: kicq-0.3.0 and licq-0.75.2, on slackware 7.0
#
###################################################################
#
# this is a little script i whipped up to convert my kicq list
# to an licq list. i have no idea if this will work for anyone
# else (besides me), but hopefully it will be of some use to
# someone somewhere.  anyways, here is how you use it:
#
#
# ./kicq2licq.pl <UIN> <TEMPLATE>
#
# **NOTE** - TEMPLATE may be an existing Licq UIN.uin file:
#
#
# $ licq.kicqconvert 29690151 ~/.licq/users/1234567.uin
#
# or you may use this template (remove all leading #'s).
# copy from CUT line to CUT line, paste it into another
# file, and remove all the leading #'s (;
#
# don't uncomment them here, or you are in for hard times.
#
########### CUT ###############

#[user]
#History = 
#Groups.System = 
#Groups.User = 
#Ip = 
#Port = 
#NewUser = 
#NewMessages = 
#LastOnline = 
#Alias = 
#FirstName = 
#LastName = 
#Email1 = 
#Email2 = 
#City = 
#State = 
#PhoneNumber = 
#FaxNumber = 
#Address = 
#CellularNumber = 
#Zipcode = 
#Country = 
#Timezone = 
#Authorization = 
#HideEmail = 
#Age = 
#Gender = 
#Homepage = 
#BirthYear = 
#BirthMonth = 
#BirthDay = 
#Language1 = 
#Language2 = 
#Language3 = 
#CompanyCity = 
#CompanyState = 
#CompanyPhoneNumber = 
#CompanyFaxNumber = 
#CompanyAddress = 
#CompanyName = 
#CompanyDepartment = 
#CompanyPosition = 
#CompanyHomepage = 

########### CUT ###############
#
#
# if one were so inclined, they could do their entire list at
# once doing something like this:
#
# cd ~/.kde/share/apps/kicq/contacts
# for i in *.uin; do
#   UIN=`echo $i | cut -f1 -d.`
#   /path/to/kicq2licq.pl $UIN /path/to/template
# done
#
# this script doesn't require you to blow away your current
# users.conf, it will rebuild it with the person you just added.
#
# i.e. - you have 1 person on your Kicq list, and 3 on your Licq
# list, and you run the script on your single Kicq user, the script
# should update your users.conf file to 4 users.  if you have no
# clue what i'm talking about, then you are out of luck.  it's 3
# a.m. and i haven't a clue either.  you can email me if you want
# i'll try and help.
#


use strict;


my ($licq_template, $kicq_user);


## make sure we have proper args
$kicq_user     = $ARGV[0] || die("usage: $0 <UIN> <template>\n");
$licq_template = $ARGV[1] || die("usage: $0 <UIN> <template>\n");



## let the fun begin
write_licq_list($kicq_user, $licq_template);


##
## this function will break the kicq user.uin list
## into a hash, break the licq template into
## a hash, then break the licq users.conf file into
## a hash, create a new users.conf (updated for the
## new user), and create a UIN.uin file in the users/
## directory with information from the kicq UIN.uin
## file
##

sub write_licq_list()
{
    my ($kicq_uin, $licq_template) = @_;
    my ($output_file, $key, $value, %kicq_hash, %licq_hash, %conf_hash, $licq_conf);


    ## change these if you have a weird install of
    ## licq, or i'm a dork and screwed something
    ## up.
    $licq_conf   = "$ENV{'HOME'}/.licq/users.conf";
    $output_file = "$ENV{'HOME'}/.licq/users/$kicq_uin.uin";


    ## parse the kicq list (;
    %kicq_hash = parse_kicq_list($kicq_uin);


    ## parse the licq template.
    %licq_hash = parse_licq_list($licq_template);


    ## parse the users.conf file, and store it in a hash
    %conf_hash = parse_licq_conf();



    ## if we already have an existing UIN.uin, lets die.
    die("$output_file exists exiting") if -e $output_file;


    ## print basic headers for the UIN.uin file.
    open(OUT, ">$output_file");
    print(OUT "\n");
    print(OUT "[user]\n");


    ## sort through all the licq template values
    ## and see if we have a matching kicq key.
    ## if we do, we take the value of what the
    ## kicq user.uin file had for it.  if not
    ## we just leave it blank.

    while   (($key, $value) = each(%licq_hash))
    {
        ## we have a match.
        if (exists($kicq_hash{$key}))
        {
            print(OUT "$value = $kicq_hash{$key}\n");
        }

        ## leave it blank.
        else
        {
            print(OUT "$value =\n");
        }
    }
    ## close the output file
    close(OUT);



    ## open the users.conf file now.
    open(CONF, ">$licq_conf");


    ## we are adding one user at a time, so we
    ## increment the value of NumOfUsers we got
    ## from parse_licq_conf() by one.
    $conf_hash{'NumOfUsers'}++;


    # print normal users.conf header stuff.
    print(CONF "[users]\n");
    print(CONF "NumOfUsers = $conf_hash{'NumOfUsers'}\n");


    ## sort through the rest of the keys and values
    ## we pulled out of the users.conf, and put them
    ## back into place.  NOTE - these aren't sorted
    ## so you may get User10, then User2.  Licq does
    ## not seem to care, so i don't either. (=

    while   (($key, $value) = each(%conf_hash))
    {
        ## we printed this already, so lets skip it
        if ($key ne "NumOfUsers")
        {
            print(CONF "$key = $value\n");
        }
    }


    ## this is the user we are wanting to add.
    ## so we add this at the end of the list.
    print(CONF "User$conf_hash{'NumOfUsers'} = $kicq_uin\n");


    ## close the users.conf file
    close(CONF);
        
        
    ## all done.
    exit(1);
}


##
## this function will user read the users.conf
## file into a hash, skipping any newlines,
## comments or [user] type lines.
##
sub parse_licq_conf()
{
    ## change this to suit you.  this is where mine was.
    my ($licq_conf) = "$ENV{'HOME'}/.licq/users.conf";

    my (%conf_hash, $key, $value);


    ## can't read it if it's not there.
    die("could not find your $licq_conf\n") if ! -e $licq_conf;


    ## open the config file for reading
    open(CONF, $licq_conf);


    ## read the whole config file.
    while   (<CONF>)
    {
        chomp; 


        ## skip comments, [user] type stuff, and blank lines
        next if /^[#\[]|^$/;


        ## split the line into 2 values
        ($key, $value) = split(/ = /, $_);


        ## create the hash element with the 2 values.
        $conf_hash{$key} = $value;
    }
    ## close the config file.
    close(CONF);


    ## return the hash we built.
    return(%conf_hash);
}


##
## this function just reads the kicq UIN.uin file,
## and creates a hash all the values we have set.
## this is done so later we can compare the licq
## keys, against these and see if we have any that
## are the same (as opposed to losing that info).
##

sub parse_kicq_list()
{
    my ($kicq_file) = @_;
    my (%kicq_hash, $key, $value);


    ## this is where my kicq UIN.uin files were stored,
    ## change this if it is different for you.
    $kicq_file = "$ENV{'HOME'}/.kde/share/apps/kicq/contacts/$kicq_file.uin";


    ## can't read it if it doesn't exist right?
    open(KICQ, $kicq_file) || die("couldn't open $kicq_file - $!\n");


    ## read through all the entries in the UIN.uin file
    while   (<KICQ>)
    {
        chomp;  


        ## skip comments, [user] type stuff, and blank lines
        next if /^[#\[]|^$/;


        ## split the line into 2 values
        ($key, $value) = split(/=/, $_);


        ## make the key all lowercase, so we don't have to
        ## worry about case issues with the licq hash.
        $key =~ tr/[A-Z]/[a-z]/;


        ## create the hash element.
        $kicq_hash{$key} = $value;
    }
    ## close the UIN.uin file.
    close(KICQ);


    ## return the hash we built
    return(%kicq_hash);
}


##
## this function will just read the template
## specified on the command line, create a
## hash of all the keys (everything on the
## right side of the ='s are tossed).  so
## in the end we end up with this:
##
## $hash{lower_case_key} = Lower_Case_Key;
##

sub parse_licq_list()
{
    my ($licq_file) = @_;
    my (%licq_hash, $key, $tmp_key, $value);


    ## can't read it if it doesn't exist right?
    open(LICQ, $licq_file) || die("couldn't open $licq_file - $!\n");

    while   (<LICQ>)
    {
        chomp;  

        ## skip comments, [user] type stuff, and blank lines
        next if /^[#\[]|^$/;


        ## split the line into 2 values
        ($key, $value) = split(/ = /, $_);


        ## we store the key in a temp variable
        ## because we are going to turn the key
        ## to all lower case, and i don't know
        ## if Licq would freak with that.

        $tmp_key = $key;


        ## make the key all lowercase, so we don't have to
        ## worry about case issues with the kicq hash.
        $key =~ tr/[A-Z]/[a-z]/;


        ## since we don't have any real values (we discarded
        ## everything on the right of the =), we will store
        ## the unmodified (real key) name.
        $licq_hash{$key} = $tmp_key;

    }
    ## close the template
    close(LICQ);


    ## return the hash we built
    return(%licq_hash);
}
# EOF