Free large groups software for linux

WWW::Google::Groups is a Perl module for Google Groups Agent.

BROWSING

use WWW::Google::Groups;

$agent = new WWW::Google::Groups
(
server => groups.google.com,
proxy => my.proxy.server:port,
);


$group = $agent->select_group(comp.lang.perl.misc);

$group->starting_thread(0); # Set the first thread to fetch
# Default starting thread is 0

while( $thread = $group->next_thread() ){
while( $article = $thread->next_article() ){

# the returned $article is an Email::Simple object
# See Email::Simple for its methods

print join q/ /, $thread->title, header(From).>, $/;
}
}
If you push raw to the argument stack of $thread->next_article(), it will return the raw format of messages.
while( $thread = $group->next_thread() ){
while( $article = $thread->next_article(raw) ){
print $article;
}
}
Even, you can use this more powerful method. It will try to mirror the whole newsgroup and save the messages to a Unix mbox.
$agent->save2mbox(
group => comp.lang.perl.misc,
starting_thread => 0,
max_article_count => 10000,
max_thread_count => 1000,
target_mbox => perl.misc.mbox,
);

WWW::Yahoo::Groups is an automated access to Yahoo! Groups archives.

SYNOPSIS

my $y = WWW::Yahoo::Groups->new();
$y->login( $user => $pass );
$y->list( Jade_Pagoda );
my $email = $y->fetch_message( 2345 );

# Error catching
my $email = eval { $y->fetch_message( 93848 ) };
if ( $@ and ref $@ and $@->isa(X::WWW::Yahoo::Groups) )
{
warn "Problem: ".$@->error;
}

WWW::Yahoo::Groups retrieves messages from the archive of Yahoo Groups. It provides a simple OO interface to logging in and retrieving said messages which you may then do with as you will.

Things it does

Handles access to restricted archives. It lets you login.
Handles the intermittent advertisements. It notes that it got one and progresses straight to the message.
Handle adult confirmation requests. It just goes straight on.
Handles attachments. We get the source which happens to be the raw stuff.
Sanity checking. Could be improved, but it will generally barf if it doesnt understand something.
Header restoration. Ive found that some groups archives have unusually corrupted headers. Evidently it would be beneficial to restore these headers. As far as I can tell, it comes from not being a moderator on the lists in question.

USAGE

Try to be a well behaved bot and sleep() for a few seconds (at least) after doing things. Its considered polite. Theres an autosleep method that should be useful for this. Recently, this has been set to a default of 1 second. Feel free to tweak if necessary.

If youre used to seeing munged email addresses when you view the message archive (i.e. youre not a moderator or owner of the group) then youll be pleased to know that WWW::Yahoo::Groups can demunge those email addresses.

All exceptions are subclasses of X::WWW::Yahoo::Groups, itself a subclass of Exception::Class. See WWW::Yahoo::Groups::Errors for details.

GROUP-E project is collaboration software which integrates groupware, project management, and business server on one platform. The solution is based on a LAMP architecture (Linux, Apache, MySQL, PHP).
GROUP-E offers project management, transparent Samba (file server) integration, integration of Cyrus IMAP server with administration and personal SIEVE filters, support for SyncML 1.0, LDAP-based user management with single sign-on authentication, and LDAP contact databases.
Enhancements:
- A fix for an LDAP-Dump bug, new drag and drop support in the calendar module (ajax), automatic deleting of old emails in preferences (ajax), and various bugfixes for the SyncML Server (now all Symbian 60 mobiles works without problems, also syncevolution works now).

Math::Group::Thompson Perl module contains OO methods that calculates the cardinality of the ball of radius n of Thompson group F.

SYNOPSIS

use Math::Group::Thompson;

my $F = Math::Group::Thompson->new( VERBOSE => 0 );
my $card = $F->cardBn(3,);

print "#B(3) = $cardn";

The Math::Group::Thompson module provides objetct oriented methods that calculates the cardinality of the ball of radius n of Thompson group F.

This module uses the presentation of F

F = < A,B | [AB^(-1),A^(-1)BA] = [AB^(-1),A^(-2)BA^2] = e >

where A,B are formal symbols, [x,y] is the usual commutator and e is the identity element of F.

[x,y] = xyx^(-1)y^(-1)

This means that for every g in F, g can be written as word

g = a_{1}a_{2} ... a_{n}

where all the a_{i} are A,B,A^(-1) or B^(-1) for all i r br Usage: my $F = new-Math::Group::Thompson( VERBOSE => $v );
Verbose argument tells Math::Group::Thompson whether print every word generated ($v == 1) or not ($v == 0), or store them in a file, where $v is the name of the file (obviously different to 0 or 1). If the verbose file exists it is replaced, so you have to check for its integrity.

NOTE:
Its not recommend to store the words on a file because for
very small values of n, #B(n) or #gB(n)-B(n) are very very large.
For example for n = 19, #B(n) ~ 3^n = 1162261467 ~ 1.1 Giga, but
the space ocupped by the file will be (in bytes):

#B(1) + sum(i=2 to 19){i*(#B(i) - #B(i-1))} =
cardBn

This method calculates #B(n) or #(gB(n) - B(n)) depending on if the argument passed to the first call of cardBn is or not.

Usage: my $c = $F->cardBn($radius,$g);

where

$radius is an integer number >= 0 and $g is an element of F (word written with A,B,C or D).

If the first time cardBn is called $g is not equal to , then cardBn returns the cardinality of the set

gB(n) - B(n) = { w in F | w in gB(n) and w not in B(n) }

If the firs time cardBn is callen $g is equal to , then cardBn returns #B(n).

This algorithm runs on exponential time because F is of exponential growth (more "exactly", this algorithm is O(3^n) ).

reset

Resets the counter used on cardBn method, set the FIRST_ELEMENT property at , and the FIRST_CALL proporty to 1.

Usage: $F->reset;

multiply

Multiplication between two words of F. This method considers the inverse relations stored in the attribute INV.

Usage: my $mul = $F->multiply($g,$w);

where $g and $w are elements of F, and $mul is the result of $g$w.

rotate

This module receives as argument a word in F and puts the last letter on word in its first place.

Usage: $w = ABC; $W = $self->rotate($w); # $W is now equal to CBA

inverse

This method receives a word in F and returns its inverse.

Usage: $w = ABC; $W = $self->inverse($w); # $W == ADC

divide

This method receives a word in F and returns a 2-dimensional array where the first element is the first half of the word, and the second is the inverse of the second half of the word.

Usage: $w = AABC; ($w1,$w2) = $self->divide($w); # Now $w1 == AA and $w2 == AD

get_inv

This method return the hash of inverse relations between the generators elements of F.

note

This method prints in STDERR the string received or puts it on the correspondent file.

Usage: $F->note(AA); # Print AA."n" or store it on a file.

Group User Folder provides a Zope Product that manages Groups of Users.
GroupUserFolder is a kind of user folder that provides a special kind of user management. Some users are "flagged" as GROUP and then normal users will be able to belong to one or serveral groups.
Enhancements:
- Fix _getMemberIds for LDAPUserFolder 2.7 when groups are stored in LDAPUF [encolpe]
- Got rid of zLOG in favor of logging. [stefan]

jLibrary is a Document Management System oriented for personal and enterprise use. This double approach make from jLibrary an unique product.
With jLibrary, you can classify your documents, videos, or any other media type. You can export those contents to static web pages based on templates, search on those content, add comments, categorize it, etc.
Companies can find in jLibrary all the features present in most modern content management systems, including team work support, version management, offline document edition, document locking, security constraints based on roles, users and groups, easy web access, etc.
jLibrary is multiplatform, so you can run the client and the server in both Windows and Linux. jLibrary is based on web services so it boosts interoperatility between platform and lenguages, being an ideal solution for heterogeneous environments.
Main features:
- Create a fashion web application using last technologies like Java Server Faces or AJAX.
- Improve data and text mining support.
- Add more document types support. Ex: Open Office files.
- Improve relationship browser.
- Create installers for different platforms.
- Improve the image editor.
- Add encryption support.
- Add basic workflow support (closed, opened, pending, ...).
- Create a .NET browser complementary to the current J2EE browser.
- And more, and more, and more...
Enhancements:
- Performance was improved and memory compsumption was reduced, especially when handling large files.
- The main changes are a new HTTP tunnelling layer, support for custom properties for documents, a new Maven 2 based deployment system that is especially handy for client side builds, and plenty of unit tests to help developers starting up with jLibrary.
- Many bugs were fixed both in the server and client sides.
- Eclipse 3.2 core infrastructure has been added.
- There are now stable versions for Linux and Mac OS X.

Mail::Abuse::Reader::GoogleGroups is a Perl module that reads Mail::Abuse::Report from NANAS via Google Groups.

SYNOPSIS

use Mail::Abuse::Report;
use Mail::Abuse::Reader::GoogleGroups;
my $r = new Mail::Abuse::Reader::GoogleGroups;
my $report = new Mail::Abuse::Report (reader => $r);

THIS CODE SHOULD NOT BE USED IN PRODUCTION YET. SEE bin/google-gather INSTEAD, FOR AN ALTERNATE MECHANISM OF FETCHING REPORTS FROM NANAS VIA GOOGLE GROUPS.

This module uses the news.admin.net-abuse.sightings archive kindly provided by the Google(tm) Groups service to feed public complaints into the Mail::Abuse package.
The general idea is that a search is going to be performed and each result will be fed into the Mail::Abuse engine. The parameters of the process can be configured by the following keys in the configuration file.

google groups search

Regexp to search for in the text of each article.

google groups max messages

Maximum number of messages to read in a single run. Defaults to 50.

google groups oldest message

Controls the maximum age of a message. Messages that are older (accorging to its Date: header) will be skipped and not counted. This defaults to five days.

google groups server

The name of the Google(tm) Groups server to use. Defaults to groups.google.com.

google groups proxy

The proxy server to use.

debug google groups

When set to a true value, causes debug information to be sent to STDERR.

The following methods are implemented within this class.

read($report)

Populates the text of the given $report using the ->text method. Must return true if succesful or false otherwise.

Mail::Summary::Tools::ArchiveLink::GoogleGroups is link to Google Groups via message ID.

SYNOPSIS

use Mail::Summary::Tools::ArchiveLink::GoogleGroups;

my $link = Mail::Summary::Tools::ArchiveLink::GoogleGroups->new(
message_id => ".....",
);

$link->thread_uri;
$link->message_uri;

Currently this module allows retrieval of message lists, raw messages, and the contact list. All requests to gmail are secured using ssl.