Free public relations software for linux

Relations is a Perl module with functions to use with databases and queries.

SYNOPSIS

use Relations;

$as_clause = as_clause({full_name => "concat(f_name, ,l_name)",
{status => "if(married,Married,Single)"})

$query = "select $as_clause from person";

$avoid = to_hash("virustbug","t");

if ($avoid->{bug}) {

print "Avoiding the bug...";

}

unless ($avoid->{code}) {

print "Not avoiding the code...";

}

Relations::Query is a Perl Object for building queries with DBI/DBD::mysql.

SYNOPSIS

# Relations::Query Script that creates some queries.

use Relations::Query;

$query = new Relations::Query(-select => {fife => barney},
-from => {green_teeth => moogoo},
-where => "flotsam>jetsam",
-group_by => "denali",
-having => {fortune => cookie},
-order_by => [was,is,will],
-limit => 1);

$get_query = $query->get();

$query->set(-select => {clean => sparkle},
-from => {lean => book},
-where => "fighting is between courage and chaos",
-limit => 123);

$set_query = $query->get();

$get_add_query = $query->get_add(-select => {mean => dog},
-where => "running is null",
-having => {kitties=> on_tv},
-limit => [9678]);

$query = to_string({select => this,
from => that});

Relations::Family is a DBI/DBD::mysql Relational Query Engine module.

SYNOPSIS

# DBI, Relations::Family Script that creates some queries.

#!/usr/bin/perl

use DBI;
use Relations::Family;

$dsn = "DBI:mysql:finder";

$username = "root";
$password = ;

$dbh = DBI->connect($dsn,$username,$password,{PrintError => 1, RaiseError => 0});

$abstract = new Relations::Abstract($dbh);

$family = new Relations::Family($abstract);

$family->add_member(-name => account,
-label => Cust. Account,
-database => finder,
-table => account,
-id_field => acc_id,
-query => {-select => {id => acc_id,
label => "concat(cust_name, - ,balance)"},
-from => [account,customer],
-where => "customer.cust_id=account.cust_id",
-order_by => "cust_name"});

$family->add_member(-name => customer,
-label => Customer,
-database => finder,
-table => customer,
-id_field => cust_id,
-query => {-select => {id => cust_id,
label => cust_name},
-from => customer,
-order_by => "cust_name"});

$family->add_member(-name => purchase,
-label => Purchase,
-database => finder,
-table => purchase,
-id_field => pur_id,
-query => {-select => {id => pur_id,
label => "concat(
cust_name,
- ,
date_format(date, %M %D, %Y)
)"},
-from => [purchase,
customer],
-where => customer.cust_id=purchase.cust_id,
-order_by => [date desc,
cust_name]});

$family->add_lineage(-parent_name => customer,
-parent_field => cust_id,
-child_name => purchase,
-child_field => cust_id);

$family->add_rivalry(-brother_name => customer,
-brother_field => cust_id,
-sister_name => account,
-sister_field => cust_id);

$family->set_chosen(-label => Customer,
-ids => 2,4);

$available = $family->get_available(-label => Purchase);

print "Found $available->{count} Purchases:n";

foreach $id (@{$available->{ids_array}}) {

print "Id: $id Label: $available->{labels_hash}->{$id}n";

}

$family->add_value(-name => Cust. Account,
-sql => "concat(cust_name, - ,balance)",
-member_names => customer,account);

$family->add_value(-name => Paid,
-sql => "if(balance > 0,NO,YES)",
-member_names => account);

$family->add_value(-name => Customer,
-sql => cust_name,
-member_names => customer);

$family->add_value(-name => Purchase,
-sql => "concat(
cust_name,
- ,
date_format(date, %M %D, %Y)
)",
-member_names => purchase,customer);

$reunion = $family->get_reunion(-data => Paid,Purchase,
-use_labels => Customer,
-order_by => Customer,Purchase);

$matrix = $abstract->select_matrix(-query => $reunion);

print "Found " . scalar @$matrix . " Values:n";

foreach $row (@$matrix) {

print "Customer: $row->{Customer}n";
print "Purchase: $row->{Purchase}n";
print "Paid: $row->{Paid}nn";

}

$dbh->disconnect();

Object::Relation::DataType is a Perl module with complex data types for TKP.

The Object::Relation::DataType name space is set aside for the creation of complex data types for TKP. By "complex" I mean serializable objects, such as dates, durations, states, etc. It also is designed to create a distinction from simpler data types, which are defined in Object::Relation::Meta::DataTypes.

What creates the distinction? Well, first and foremost is that fact that it doesnt usually take much to create the simple data types, while the complex data types might need more code to handle serialization and deserialization, overloading, etc.

But another criterion is that, while the data types in Object::Relation::Meta::DataTypes are always loaded by TKP, since it uses them for its own classes, the complex data types in the Object::Relation::DataType name space tend to be loaded only as needed by the Object::Relation business classes that need them.

Okay, so its somewhat arbitrary, but you get the idea. The remainder of this document is dedicated to documenting how to add new data types to TKP.

Matrix Public Net spreads short voice messages through a web of trust; credibility decays until a threshold where the message is dropped.

Matrix Public Net comes with a program for recording and sending messages as well as plugins for XMMS and WinAmp that play received messages.

Extending the Blogosphere

This is a proposal for the extension of the Blogosphere, the network of Weblogs.
Individual Blogs are connected by their users implicitly: a community emerges, because users regularly read and comment on others entries. By making this connexions explicit, a web of trust is created which functions like a reputation mechanism.

The resulting system leverages the advantages of social networks for the distribution of news. It can be implemented as a decentralised system, with a simple extension to the Blogosphere.

The system is explained in a paper and in the presentation at the Mobile Entertainment conference in Manchester.

The RSS MPN-Interest module is the first part of this extension.

Konq Rellinks is an add-on for Konqueror, the official KDE browser.
It allows you to access the relations defined in the header of the document. These relations can be links to other versions of the document, RSS backend, search page, copyright informations,.... For more informations about this, see The link-Element in (X)HTML .
The look of the Rellinks add-on is similar to the "Site Navigation Toolbar" of the Mozilla browser (not Mozilla Firebird).
Enhancements:
- Support for "target" attribute,
- Distinction between "rel" and "rev" relations

Object::Relation::Meta::Class::Schema is a Perl module for Object::Relation database store builder.

This module is provides metadata for all Object::Relation classes while building a storage schema. Loading Object::Relation::Schema causes it to be used instead of Object::Relation::Meta::Class. This is so that extra metadata methods are available that are useful in constructing the schema, but are not otherwise useful when an application is actually in use.

At this point, those attributes tend to be database-specific. Once other types of data stores are added (XML, LDAP, etc.), other attributes may be added to allow their schemas to be built, as well.

Object::Relation::Meta::Attribute::Schema is a Perl module for Object::Relation database store builder.

Synopsis

# Assuming MyThingy was generated by Object::Relation::Meta and that were building
# a data store schema.
my $class = MyThingy->my_class;

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, $/;
print " Column: ", $attr->column, $/;
if (my $idx = $attr->index) {
print " Index: $idxn";
}
if (my $ref = $attr->references) {
print " References ", $ref->package, $/;
print " On Delete: ", $attr->on_delete, $/;
}
}

This module is provides metadata for all Object::Relation class attributes while building a storage schema. Loading Object::Relation::Schema causes it to be used instead of Object::Relation::Meta::Attribute. This is so that extra metadata methods are available that are useful in constructing the schema, but are not otherwise useful when an application is actually in use.