// load a table into the memory manager
long CUG_HTML_DataSource::LoadTable(char* buff, char* buffEnd, int num)
{
// find table def
char* begin=FindTableStart(buff);
// if begin == "" no table found...
if(!begin)
return 0;
char* next;
char* end;
int level=0;
// keep going until we find the correct table
while(begin && num--)
{
level=0;
// skip over the rest of tag
begin = strstr(begin, ">");
ASSERT(begin);
begin++;
next=begin;
end=FindTableEnd(begin);
while((next=FindTableStart(next))!=NULL && next<end)
{
next++;
level++;
}
while(level-->0)
{
end++;
end=FindTableEnd(end);
}
// ASSERT(end);
if(num==0)
LoadRows(begin, end);
begin=begin=FindTableStart(begin);
}
return end-buff;
}
ECRESULT ECUserStoreTable::Load() {
ECRESULT er = erSuccess;
ECListIntIterator i;
ECDatabase *lpDatabase = NULL;
DB_RESULT lpDBResult = NULL;
DB_ROW lpDBRow = NULL;
DB_LENGTHS lpDBLength = NULL;
std::string strQuery;
std::list<unsigned int> lstObjIds;
ECUserStore sUserStore;
int iRowId;
ECUserManagement *lpUserManagement = lpSession->GetUserManagement();
ECSecurity *lpSecurity = lpSession->GetSecurity();
objectdetails_t sUserDetails;
GUID sZeroGuid = {0};
objectclass_t objclass;
objectdetails_t sDetails;
enum cols { USERID = 0, EXTERNID, OBJCLASS, UCOMPANY, STOREGUID, STORETYPE, USERNAME, SCOMPANY, HIERARCHYID, STORESIZE, MODTIME_HI, MODTIME_LO };
er = lpSession->GetDatabase(&lpDatabase);
if (er != erSuccess)
goto exit;
Clear();
/*
* The next query will first get the list of all users with their primary store details or NULL if
* no primary store was found. Secondly it will get the list of all stores with their owner or NULL
* if they're detached.
* The most important difference id that the first query will return no store for users without a
* primary store, even if they do have an archive store attached, while the second query will
* return all stores types.
*/
strQuery =
" SELECT u.id, u.externid, u.objectclass, u.company, s.guid, s.type, s.user_name, s.company, s.hierarchy_id, p.val_longint, m.val_hi, m.val_lo FROM users AS u"
" LEFT JOIN stores AS s ON s.user_id=u.id AND s.type=" + stringify(ECSTORE_TYPE_PRIVATE) + " LEFT JOIN hierarchy AS h ON h.id=s.hierarchy_id"
" LEFT JOIN properties AS p ON p.hierarchyid=s.hierarchy_id and p.tag=0x0E08 and p.type=0x14"
" LEFT JOIN properties AS m ON m.hierarchyid=s.hierarchy_id and m.tag=0x66A2 and m.type=0x40"
" UNION"
" SELECT u.id, u.externid, u.objectclass, u.company, s.guid, s.type, s.user_name, s.company, s.hierarchy_id, p.val_longint, m.val_hi, m.val_lo FROM users AS u"
" RIGHT JOIN stores AS s ON s.user_id=u.id LEFT JOIN hierarchy AS h ON h.id=s.hierarchy_id"
" LEFT JOIN properties AS p ON p.hierarchyid=s.hierarchy_id and p.tag=0x0E08 and p.type=0x14"
" LEFT JOIN properties AS m ON m.hierarchyid=s.hierarchy_id and m.tag=0x66A2 and m.type=0x40";
er = lpDatabase->DoSelect(strQuery, &lpDBResult);
if(er != erSuccess)
goto exit;
iRowId = 0;
while(1) {
lpDBRow = lpDatabase->FetchRow(lpDBResult);
if(lpDBRow == NULL)
break;
lpDBLength = lpDatabase->FetchRowLengths(lpDBResult);
if (lpDBRow[OBJCLASS]) {
objclass = (objectclass_t)atoi(lpDBRow[OBJCLASS]);
if (objclass != ACTIVE_USER && objclass != NONACTIVE_USER &&
objclass != NONACTIVE_ROOM && objclass != NONACTIVE_EQUIPMENT)
continue;
}
if (lpDBRow[USERID]) {
sUserStore.ulUserId = atoi(lpDBRow[USERID]);
if (sUserStore.ulUserId == ZARAFA_UID_SYSTEM) // everyone already filtered by object type
continue;
} else {
sUserStore.ulUserId = -1;
}
sUserStore.ulCompanyId = 0;
if (lpDBRow[UCOMPANY])
sUserStore.ulCompanyId = atoi(lpDBRow[UCOMPANY]);
if (lpDBRow[SCOMPANY])
sUserStore.ulCompanyId = atoi(lpDBRow[SCOMPANY]); // might override from user.company
// check if we're admin over this company
if (lpSecurity->IsAdminOverUserObject(sUserStore.ulCompanyId) != erSuccess)
continue;
if (lpDBRow[EXTERNID]) {
sUserStore.sExternId.id.assign(lpDBRow[EXTERNID], lpDBLength[EXTERNID]);
sUserStore.sExternId.objclass = objclass;
} else {
sUserStore.sExternId.id.clear();
sUserStore.sExternId.objclass = OBJECTCLASS_UNKNOWN;
}
sUserStore.strUsername.clear();
// find and override real username if possible
if (sUserStore.ulUserId != -1 && lpUserManagement->GetObjectDetails(sUserStore.ulUserId, &sUserDetails) == erSuccess) {
if (lpSession->GetSessionManager()->IsDistributedSupported()) {
if (sUserDetails.GetPropString(OB_PROP_S_SERVERNAME).compare(lpSession->GetSessionManager()->GetConfig()->GetSetting("server_name")) != 0)
continue; // user not on this server
}
sUserStore.strUsername = sUserDetails.GetPropString(OB_PROP_S_LOGIN);
}
sUserStore.sGuid = sZeroGuid;
if (lpDBRow[STOREGUID])
memcpy(&sUserStore.sGuid, lpDBRow[STOREGUID], lpDBLength[STOREGUID]);
if (lpDBRow[STORETYPE])
sUserStore.ulStoreType = atoi(lpDBRow[STORETYPE]);
else
sUserStore.ulStoreType = ECSTORE_TYPE_PRIVATE; // or invalid value?
if (lpDBRow[USERNAME])
sUserStore.strGuessname = lpDBRow[USERNAME];
else
sUserStore.strGuessname.clear();
if (sUserStore.ulCompanyId > 0 && lpUserManagement->GetObjectDetails(sUserStore.ulCompanyId, &sDetails) == erSuccess) {
sUserStore.strCompanyName = sDetails.GetPropString(OB_PROP_S_LOGIN);
}
if(lpDBRow[HIERARCHYID])
sUserStore.ulObjId = atoui(lpDBRow[HIERARCHYID]);
else
sUserStore.ulObjId = 0;
sUserStore.tModTime = 0;
if(lpDBRow[MODTIME_HI] && lpDBRow[MODTIME_LO]) {
FILETIME ft;
ft.dwHighDateTime = atoui(lpDBRow[MODTIME_HI]);
ft.dwLowDateTime = atoui(lpDBRow[MODTIME_LO]);
sUserStore.tModTime = 0;
FileTimeToUnixTime(ft, &sUserStore.tModTime);
}
if(lpDBRow[STORESIZE])
sUserStore.ullStoreSize = atoll(lpDBRow[STORESIZE]);
else
sUserStore.ullStoreSize = 0;
// add to table
lstObjIds.push_back(iRowId);
// remember details
m_mapUserStoreData.insert(std::pair<unsigned int, ECUserStore>(iRowId++, sUserStore));
}
LoadRows(&lstObjIds, 0);
exit:
if (lpDBResult) {
lpDatabase->FreeResult(lpDBResult);
lpDBResult = NULL;
}
return er;
}
// --------------------------------------------------------------------------------//
// MAIN //
// --------------------------------------------------------------------------------//
int main(int argc, char* argv[])
{
// process command-line arguments
if (argc<2) { Usage(); exit(1); }
char *method = argv[1];
CmdLine *cmdLine = InitCmdLine(method);
//--------------------------------------------------------------------------------------//
// OPTION -permute: permute rows //
//--------------------------------------------------------------------------------------//
if (strcmp(method,"-permute")==0) {
// read options
cmdLine->Read(argv+1,argc-1);
MESSAGES(VERBOSE);
// initialize random generator
unsigned long int seed = RND_SEED+getpid()+time(NULL);
gsl_rng *RANDOM_GENERATOR = InitRandomGenerator(seed);
// read input
long int n_lines;
char **L;
FILE *fp = LoadStdIn(&n_lines,BUFFER_SIZE);
if (n_lines==0) return 0;
ALLOCATE1D(L,n_lines,char *);
FileBufferText *buffer = new FileBufferText(fp,BUFFER_SIZE);
Progress PRG("Reading input rows...",n_lines);
for (long int n=0; n<n_lines; n++) {
L[n] = StrCopy(buffer->Next());
PRG.Check();
}
PRG.Done();
// permute
long int *seq;
ALLOCATE1D(seq,n_lines,long int);
for (long int k=0; k<n_lines; k++) seq[k] = k;
gsl_ran_shuffle(RANDOM_GENERATOR,seq,n_lines,sizeof(long int));
// print output
Progress PRG1("Printing output rows...",n_lines);
for (long int n=0; n<n_lines; n++) {
printf("%s\n", L[seq[n]]);
PRG1.Check();
}
PRG1.Done();
// cleanup
FREE1D(seq);
delete RANDOM_GENERATOR;
delete buffer;
}
//--------------------------------------------------------------------------------------//
// OPTION -resample: resample rows //
//--------------------------------------------------------------------------------------//
else if (strcmp(method,"-resample")==0) {
// read options
cmdLine->Read(argv+1,argc-1);
MESSAGES(VERBOSE);
// initialize random generator
unsigned long int seed = (RND_SEED==0)?(getpid()+time(NULL)):RND_SEED;
gsl_rng *RANDOM_GENERATOR = InitRandomGenerator(seed);
// read input
long int n_lines;
char **L;
FILE *fp = LoadStdIn(&n_lines,BUFFER_SIZE);
if (n_lines==0) return 0;
ALLOCATE1D(L,n_lines,char *);
FileBufferText *buffer = new FileBufferText(fp,BUFFER_SIZE);
Progress PRG("Reading input rows...",n_lines);
for (long int n=0; n<n_lines; n++) {
L[n] = StrCopy(buffer->Next());
PRG.Check();
}
PRG.Done();
// print output
if (N_SAMPLES<=0) N_SAMPLES = n_lines;
Progress PRG1("Printing output rows...",N_SAMPLES);
for (long int n=0; n<N_SAMPLES; n++) {
long int k = gsl_rng_uniform_int(RANDOM_GENERATOR,n_lines);
printf("%s\n", L[k]);
PRG1.Check();
}
PRG1.Done();
// cleanup
delete RANDOM_GENERATOR;
delete buffer;
}
//--------------------------------------------------------------------------------------//
// OPTION -number: do row numbering //
//--------------------------------------------------------------------------------------//
else if (strcmp(method,"-number")==0) {
// read options
cmdLine->Read(argv+1,argc-1);
MESSAGES(VERBOSE);
// read input
FileBufferText buffer((char*)NULL,BUFFER_SIZE);
Progress PRG("Reading input rows...",1);
long int id = HEADER?0:1;
for (char *inp=buffer.Next(); inp!=NULL; inp=buffer.Next()) {
if (id==0) printf("\t");
else printf("%s%012ld\t", PREFIX, id);
printf("%s\n", inp);
id++;
PRG.Check();
}
PRG.Done();
}
//--------------------------------------------------------------------------------------//
// OTHER OPTIONS //
//--------------------------------------------------------------------------------------//
else {
// read options
int next_arg = cmdLine->Read(argv,argc);
MESSAGES(VERBOSE);
// allocate buffer
char *BUFFER = (char *) malloc(BUFFER_SIZE*sizeof(char));
if (BUFFER==NULL) { fprintf(stderr, "Out of memory!\n"); exit(1); }
Sequence rows = strlen(ROW_FILE)==0 ? GetRows(&argv[next_arg],argc-next_arg) : LoadRows(ROW_FILE);
// option 1: use period
if (PERIOD>0) {
int choose = MERGE ? -1 : atoi(argv[next_arg]);
//printf("(PERIOD,NEXTARG,CHOOSE) = (%i,%i,%i)\n", PERIOD, next_arg, choose);
for (int n=0; ; n++) {
if (fgets(BUFFER,BUFFER_SIZE,stdin)==NULL) break;
if (BUFFER[strlen(BUFFER)-1]!='\n') {
fprintf(stderr, "Error: line was only partially read (max chars=%i)!\n", BUFFER_SIZE); exit(1);
}
if (BUFFER[strlen(BUFFER)-1]=='\n') BUFFER[strlen(BUFFER)-1] = 0;
if (MERGE) printf("%s%s", BUFFER, n%PERIOD==PERIOD-1?"\n":SEPARATOR);
else if (n%PERIOD==choose) printf("%s\n", BUFFER);
}
}
// option 2: choose rows
else {
if (EXCLUDE==true) {
for (long int n=0,k=1; k<=rows[0]; n++) {
fgets(BUFFER,BUFFER_SIZE,stdin);
if (feof(stdin)) break;
if (BUFFER[strlen(BUFFER)-1]!='\n') { fprintf(stderr, "Error: line was only partially read (max chars=%i)!\n", BUFFER_SIZE); exit(1); }
if (n<rows[k]) printf("%s", BUFFER);
else { ++k; if (EMPTY) printf("\n"); }
}
while (true) {
fgets(BUFFER,BUFFER_SIZE,stdin);
if (feof(stdin)) break;
if (BUFFER[strlen(BUFFER)-1]!='\n') { fprintf(stderr, "Error: line was only partially read (max chars=%i)!\n", BUFFER_SIZE); exit(1); }
printf("%s", BUFFER);
}
}
else {
for (long int n=0,k=1; k<=rows[0]; n++) {
fgets(BUFFER,BUFFER_SIZE,stdin);
if (feof(stdin)) break;
if (BUFFER[strlen(BUFFER)-1]!='\n') { fprintf(stderr, "Error: line was only partially read (max chars=%i)!\n", BUFFER_SIZE); exit(1); }
if (n==rows[k]) { printf("%s", BUFFER); k++; }
else if (EMPTY) printf("\n");
}
if (EMPTY) {
while (true) {
fgets(BUFFER,BUFFER_SIZE,stdin);
if (feof(stdin)) break;
if (BUFFER[strlen(BUFFER)-1]!='\n') { fprintf(stderr, "Error: line was only partially read (max chars=%i)!\n", BUFFER_SIZE); exit(1); }
printf("\n");
}
}
}
}
// clean up
FREE1D(rows);
FREE1D(BUFFER);
}
// clean up
delete cmdLine;
return 0;
}