Commit 0c55daf4 authored by jan.koester's avatar jan.koester
Browse files

userlist now seperated

parent e3dd08c0
Loading
Loading
Loading
Loading
+10 −0
Changes for data/index.html: 10 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -69,6 +69,16 @@
                text-decoration: none;
            }

            .usertoolbar li{
                list-style:none;
                display:inline-block;
                margin:1em;
            }

            table.userlist {
                margin:1em;
            }

        </style>
    </head>
    <body>
+95 −45
Changes for src/authdb.cpp: 95 added lines, 45 removed lines.
Original line number Diff line number Diff line
@@ -48,67 +48,71 @@ namespace authdb {
    class AuthDB : public libhttppp::HttpEvent{
    public:
        AuthDB(authdb::AuthBackend &backend,netplus::socket *ssock) : HttpEvent(ssock), _Backend(backend){

            _Indexpage.loadFile(_IndexElement,"../data/index.html");
        };

        void listUsers(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            _Backend.lock();

            authdb::AuthData *cur=new AuthData;

            size_t rd=sizeof(authdb::AuthHeader),end=_Backend.end();

            _Backend.setPos(rd);



            libhtmlpp::HtmlElement root;
            libhtmlpp::HtmlPage page;

            page.loadFile(root,"../data/index.html");

            libhtmlpp::HtmlString userlist,out;

            libhtmlpp::HtmlElement *content=root.getElementbyID("content");
            libhtmlpp::HtmlElement root=_IndexElement;

            libhtmlpp::HtmlElement *content=root.getElementbyID("content");

            User user;
            class UserData udat;

            userlist <<"<div><p>UserList:</p>";
            userlist <<"<div><p>UserList:</p><table class=\"userlist\">";

            while(rd<end){
                std::cout << rd << std::endl;
                authdb::AuthData *cur=new AuthData;

                _Backend.ReadAuthData(cur,rd);

                cur->data = new char[cur->datasize];
                _Backend.read((unsigned char*)cur->data,cur->datasize);

                rd=_Backend.getPos();
                if(strcmp(cur->fieldname,"username")==0){
                    AuthDataRecord *rec=new AuthDataRecord;

                uuid_t uid;
                uuid_parse(cur->uuid,uid);
                    _Backend.setPos(sizeof(AuthHeader));
                    getRecord(_Backend,rec,uid,DataType::UserData);
                    userlist+="User: ";
                if(strcmp(cur->fieldname,"username")==0){
                    try {
                        size_t upos=sizeof(authdb::AuthHeader);
                        user.info(_Backend,&uid,udat,upos);
                        userlist << "<tr><td class=\"list_username\">";
                        std::copy(cur->data,cur->data+cur->datasize,std::back_inserter(userlist));
                    userlist+=" UID: ";
                    userlist+= cur->uuid;
                    userlist+= "<br>";
                    for(AuthDataRecord *curec=rec; curec; curec=curec->next()){
                        if(strcmp(curec->Data->fieldname,"username")!=0 && curec->Data->data){
                            userlist+="  ";
                            userlist+=curec->Data->fieldname;
                            userlist+=": ";
                            std::copy(curec->Data->data,curec->Data->data+curec->Data->datasize,
                                      std::back_inserter(userlist));
                            userlist+= "<br>";
                        }
                        userlist << "</td></tr>"
                        << "<tr><td><img class=\"list_picture\" style=\"height:100px;\" src=\"/admin/getavatar/" << cur->uuid << ".jpg\" alt=\"avatar\">"
                        << "</td><td><ul><li>"
                        << "uid: " << cur->uuid
                        << "</li>"
                        << "<li><span>Username:</span><span>" << udat.getUsername() << "</span></li>"
                        << "<li><span>Firstname:</span><span>" << udat.getFirstname() << "</span></li>"
                        << "<li><span>Lastname:</span><span>" << udat.getLastename() << "</span></li>"
                        << "<li><span>Email:</span><span>" << udat.getMail() << "</span></li>"
                        << "</ul></td><td><ul class=\"usertoolbar\" >"
                        << "<li><a class=\"button\" href=\"/admin/edituser/" << cur->uuid << "\">EditUser</a></li>"
                        << "<li><a class=\"button\" href=\"/admin/removeuser/" << cur->uuid << "\">RemoveUser</a></li>"
                        << "</ul></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                    delete rec;
                }
                delete[] cur->data;
                delete cur;
            }

            userlist << "</div><div><ul><li><a class=\"button\" href=\"/admin/createuser\">CreateUser</a></li></ul></div>";
            _Backend.unlock();

            delete cur;
            userlist << "</table></div><div><ul class=\"usertoolbar\" ><li><a class=\"button\" href=\"/admin/createuser\">CreateUser</a></li></ul></div>";

            _Backend.unlock();

            content->insertChild(userlist.parse());

@@ -157,15 +161,16 @@ namespace authdb {
                    }
                }

                _Backend.lock();
                User user;
                user.create(_Backend,&udat);
                _Backend.unlock();

                std::cout << "user created!" << std::endl;
            }

            libhtmlpp::HtmlElement root;
            libhtmlpp::HtmlPage page;

            page.loadFile(root,"../data/index.html");
            libhtmlpp::HtmlPage page;

            libhtmlpp::HtmlString form,out;

@@ -185,6 +190,7 @@ namespace authdb {
                  << "</table>"
                  << "</form";

            libhtmlpp::HtmlElement root=_IndexElement;
            libhtmlpp::HtmlElement *content=root.getElementbyID("content");

            content->insertChild(form.parse());
@@ -196,15 +202,53 @@ namespace authdb {
            rep.send(curreq,out.c_str(),out.size());
        }

        void getAvatar(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            libhttppp::HttpResponse rep;
            char uid[255],ext[16];
            sscanf(curreq->getRequestURL(),"/admin/getavatar/%[^.].%s",uid,ext);

            _Backend.lock();

            authdb::AuthData *cur;

            size_t rd=sizeof(authdb::AuthHeader),end=_Backend.end();

            while(rd<end){
                cur=new AuthData;
                cur->data=nullptr;
                _Backend.ReadAuthData(cur,rd);
                rd=_Backend.getPos()+cur->datasize;

                if(cur && strcmp(cur->uuid,uid)==0 && strcmp(cur->fieldname,"avatar")==0){
                    cur->data = new char[cur->datasize];
                    _Backend.read((unsigned char*)cur->data,cur->datasize);
                    char ctype[255];
                    snprintf(ctype,255,"image/%s",ext);
                    rep.setContentType(ctype);
                    rep.send(curreq,cur->data,cur->datasize);
                    end=0;
                    delete[] cur->data;
                }
                delete cur;
            }

            if(end!=0){
                rep.setState(HTTP404);
                rep.send(curreq,nullptr,0);
            }

            _Backend.unlock();
        };

        void AdminController(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            if(strncmp(curreq->getRequestURL(),"/admin/listusers",16)==0){
                listUsers(curreq,tid,args);
            }else if(strncmp(curreq->getRequestURL(),"/admin/createuser",17)==0){
                createUser(curreq,tid,args);
            }else if(strncmp(curreq->getRequestURL(),"/admin/getavatar/",17)==0){
                getAvatar(curreq,tid,args);
            }else{
                libhtmlpp::HtmlElement root;
                libhtmlpp::HtmlPage page;
                page.loadFile(root,"../data/index.html");
                libhtmlpp::HtmlElement root=_IndexElement;
                libhtmlpp::HtmlString out;
                libhtmlpp::print(&root,out,true);

@@ -231,6 +275,8 @@ namespace authdb {
        };
    private:
        authdb::AuthBackend    &_Backend;
        libhtmlpp::HtmlElement  _IndexElement;
        libhtmlpp::HtmlPage     _Indexpage;
    };

    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value){
@@ -240,17 +286,19 @@ namespace authdb {
            backend.ReadAuthData(user,rd);
            rd=backend.getPos();
            if(strcmp(user->fieldname,fieldname) == 0){
                user->data = new char[user->datasize];
                backend.read((unsigned char*)user->data,user->datasize);
                if(strcmp(user->data,value) == 0){
                    delete[] user->data;
                    delete user;
                    return brd;
                    goto VALUEFOUND;
                }
                delete[] user->data;
            }
            brd=rd;
            delete[] user->data;
        }
VALUEFOUND:
        delete user;
        return -1;
        return brd;
    }

    AuthDataRecord::AuthDataRecord(){
@@ -290,9 +338,11 @@ namespace authdb {

        while(rd<end){
            backend.ReadAuthData(cur,rd);
            rd=backend.getPos();
            rd=backend.getPos()+cur->datasize;
            if(strcmp(cur->uuid,plainid) == 0 && cur->type == type){
                memcpy(curec->Data,cur,sizeof(*cur));
                memcpy(curec->Data,cur,sizeof(AuthHeader));
                curec->Data->data=new char[cur->datasize];
                backend.read((unsigned char*)curec->Data->data,cur->datasize);
                if(rd<backend.end()){
                    curec->_next=new AuthDataRecord;
                    curec=curec->_next;
+119 −26
Changes for src/user.cpp: 119 added lines, 26 removed lines.
Original line number Diff line number Diff line
@@ -28,12 +28,8 @@
#include "types.h"
#include "user.h"

authdb::UserData::UserData(uuid_t id){
    new AuthDataRecord;

    uuid_unparse(id,uid);

    Data=nullptr;
authdb::UserData::UserData(){
    Data=new AuthDataRecord;
    username=nullptr;
    firstname=nullptr;
    lastname=nullptr;
@@ -42,6 +38,10 @@ authdb::UserData::UserData(uuid_t id){
    avatar=nullptr;
}

authdb::UserData::UserData(uuid_t id) : UserData(){
    uuid_unparse(id,uid);
}

authdb::UserData::~UserData(){
    delete Data;
}
@@ -81,13 +81,21 @@ void authdb::UserData::setFirstName(const char* src){

    memcpy(target->Data->uuid,uid,strlen(uid)+1);
    snprintf(target->Data->fieldname,255,"%s","firstname");
    target->Data->datasize=strlen(src);
    target->Data->datasize=strlen(src)+1;
    target->Data->data= new char[target->Data->datasize];
    memcpy(target->Data->data,src,target->Data->datasize);

    firstname=target;
}

const char *authdb::UserData::getFirstname(){
    if(firstname && firstname->Data)
        return firstname->Data->data;
    else
        throw(authdb::AuthBackendError("data not found !"));
}


void authdb::UserData::setLastName(const char* src){
    AuthDataRecord *target=lastname;

@@ -122,13 +130,21 @@ void authdb::UserData::setLastName(const char* src){

    memcpy(target->Data->uuid,uid,strlen(uid)+1);
    snprintf(target->Data->fieldname,255,"%s","lastname");
    target->Data->datasize=strlen(src);
    target->Data->datasize=strlen(src)+1;
    target->Data->data= new char[target->Data->datasize];
    memcpy(target->Data->data,src,target->Data->datasize);

    lastname=target;
}

const char * authdb::UserData::getLastename(){
    if(lastname && lastname->Data)
        return lastname->Data->data;
    else
        throw(authdb::AuthBackendError("data not found !"));
}


void authdb::UserData::setMail(const char* src){
    AuthDataRecord *target=mail;

@@ -163,13 +179,21 @@ void authdb::UserData::setMail(const char* src){

    memcpy(target->Data->uuid,uid,strlen(uid)+1);
    snprintf(target->Data->fieldname,255,"%s","mail");
    target->Data->datasize=strlen(src);
    target->Data->datasize=strlen(src)+1;
    target->Data->data= new char[target->Data->datasize];
    memcpy(target->Data->data,src,target->Data->datasize);

    mail=target;
}

const char *authdb::UserData::getMail(){
    if(mail && mail->Data)
        return mail->Data->data;
    else
        throw(authdb::AuthBackendError("data not found !"));
}


void authdb::UserData::setPwHash(const char* src){
    AuthDataRecord *target=pwhash;

@@ -204,13 +228,21 @@ void authdb::UserData::setPwHash(const char* src){

    memcpy(target->Data->uuid,uid,strlen(uid)+1);
    snprintf(target->Data->fieldname,255,"%s","password");
    target->Data->datasize=strlen(src);
    target->Data->datasize=strlen(src)+1;
    target->Data->data= new char[target->Data->datasize];
    memcpy(target->Data->data,src,target->Data->datasize);

    pwhash=target;
}

const char * authdb::UserData::getPwHash(){
    if(pwhash && pwhash->Data)
        return pwhash->Data->data;
    else
        throw(authdb::AuthBackendError("data not found !"));
}


void authdb::UserData::setUserName(const char* src){
    AuthDataRecord *target=username;

@@ -245,13 +277,20 @@ void authdb::UserData::setUserName(const char* src){

    memcpy(target->Data->uuid,uid,strlen(uid)+1);
    snprintf(target->Data->fieldname,255,"%s","username");
    target->Data->datasize=strlen(src);
    target->Data->datasize=strlen(src)+1;
    target->Data->data= new char[target->Data->datasize];
    memcpy(target->Data->data,src,target->Data->datasize);

    username=target;
}

const char * authdb::UserData::getUsername(){
    if(username && username->Data)
        return username->Data->data;
    else
        throw(authdb::AuthBackendError("data nout found !"));
}

void authdb::UserData::setAvatar(const std::vector<char>& src){
    AuthDataRecord *target=avatar;

@@ -293,11 +332,18 @@ void authdb::UserData::setAvatar(const std::vector<char>& src){
    avatar=target;
}

#include<iostream>
void authdb::UserData::getAvatar(std::vector<char>& dest){
    if(avatar && avatar->Data)
        std::copy(avatar->Data->data,avatar->Data->data+avatar->Data->datasize,
                  std::back_inserter(dest));
    else
        throw(authdb::AuthBackendError("data nout found !"));
}

void authdb::User::create(AuthBackend &backend,class UserData* dat){
    authdb::AuthData *cur=new AuthData;

    int rd=sizeof(authdb::AuthHeader),end=backend.end();
    size_t rd=sizeof(authdb::AuthHeader),end=backend.end();

    backend.setPos(rd);

@@ -305,9 +351,11 @@ void authdb::User::create(AuthBackend &backend,class UserData* dat){

    while(rd<end){
        backend.ReadAuthData(cur,rd);
        rd=backend.getPos();
        if(strcmp(cur->fieldname,"username")==0 &&
            strncmp(cur->data,dat->username->Data->data,dat->username->Data->datasize) == 0){
        rd=backend.getPos()+cur->datasize;
        if(strcmp(cur->fieldname,"username")==0){
            cur->data=new char[cur->datasize];
            backend.read((unsigned char*)cur->data,cur->datasize);
            if(strncmp(cur->data,dat->username->Data->data,dat->username->Data->datasize) == 0){
                delete[] cur->data;
                delete cur;
                throw authdb::AuthBackendError("Create User: Username Exists aborting!");
@@ -318,35 +366,80 @@ void authdb::User::create(AuthBackend &backend,class UserData* dat){
            }
            delete[] cur->data;
        }
    }
    delete cur;

    size_t wd=end;

    for(AuthDataRecord *curec=dat->Data; curec; curec=curec->next()){
        std::cout << curec->Data->fieldname << "pos: " << wd << std::endl;
         backend.WriteAuthData(curec->Data,wd);
         wd=backend.end();
    }

}

void authdb::User::edit(AuthBackend &backend, uuid_t uid,class UserData& dat, size_t pos){
void authdb::User::edit(AuthBackend &backend, uuid_t *uid,class UserData& dat, size_t &pos){
}

void authdb::User::remove(AuthBackend &backend, uuid_t uid){
void authdb::User::remove(AuthBackend &backend, uuid_t *uid){
}

void authdb::User::info(AuthBackend &backend, uuid_t uid,class UserData& dat, size_t pos)
{
}
void authdb::User::info(AuthBackend &backend, uuid_t *uid,class UserData& dat, size_t &pos){
    size_t end=backend.end();

void authdb::User::getAdditional(AuthBackend &backend, uuid_t uid, struct AuthData& data, size_t pos){
}
    char cuid[255];

    if(!uid)
        throw AuthBackendError("user info uid required!");

void authdb::User::editAdditional(AuthBackend &backend, uuid_t uid, struct AuthData& data, const char* fieldname){
    uuid_unparse(*uid,cuid);

    while(pos<end){
        authdb::AuthData *cur=new AuthData;
        backend.ReadAuthData(cur,pos);
        pos=backend.getPos()+cur->datasize;
        if(strcmp(cuid,cur->uuid) == 0){
            uuid_t uid;
            uuid_parse(cur->uuid,uid);
            backend.setPos(sizeof(AuthHeader));
            getRecord(backend,dat.Data,uid,DataType::UserData);

            std::copy(cur->uuid,cur->uuid+(strlen(cur->uuid)+1),dat.uid);

            for(AuthDataRecord *curec=dat.Data; curec; curec=curec->next()){
                if(strcmp(curec->Data->fieldname,"username")==0){
                    dat.setUserName(curec->Data->data);
                }else if(strcmp(curec->Data->fieldname,"firstname")==0){
                    dat.setFirstName(curec->Data->data);
                }else if(strcmp(curec->Data->fieldname,"lastname")==0){
                    dat.setLastName(curec->Data->data);
                }else if(strcmp(curec->Data->fieldname,"mail")==0){
                    dat.setMail(curec->Data->data);
                }else if(strcmp(curec->Data->fieldname,"pwhash")==0){
                    dat.setPwHash(curec->Data->data);
                }else if(strcmp(curec->Data->fieldname,"avatar")==0){
                    std::vector<char> tmp;
                    std::copy(curec->Data->data,curec->Data->data+curec->Data->datasize,
                              std::back_inserter(tmp));
                    dat.setAvatar(tmp);
                }/*else{
                    while(dat.Data->Data){
                        if(!dat.Data->_next){
                            dat.Data=dat.Data->_next;
                            break;
                        }
                        dat.Data=dat.Data->_next;
                    };
                    dat.Data=new AuthDataRecord;

void authdb::User::remAdditional(AuthBackend &backend, uuid_t uid, const char* fieldname){
                    memcpy(dat.Data->Data,curec->Data,sizeof(authdb::AuthData));
                    dat.Data->Data->data=new char[curec->Data->datasize];
                    memcpy(dat.Data->Data->data,curec->Data->data,curec->Data->datasize);
                }*/
            }
        }
        delete cur;
    }
}


+9 −12
Changes for src/user.h: 9 added lines, 12 removed lines.
Original line number Diff line number Diff line
@@ -39,23 +39,24 @@
namespace authdb {
    class UserData {
    public:
        UserData();
        UserData(uuid_t id);
        ~UserData();

        void setUserName(const char* src);
        void getUsername(std::string &dest);
        const char *getUsername();

        void setFirstName(const char* src);
        void getFirstname(std::string &dest);
        const char *getFirstname();

        void setLastName(const char* src);
        void getLastename(std::string &dest);
        const char *getLastename();

        void setMail(const char* src);
        void getMail(std::string &dest);
        const char *getMail();

        void setPwHash(const char* src);
        void getPwHash(std::string &dest);
        const char *getPwHash();

        void setAvatar(const std::vector<char> &src);
        void getAvatar(std::vector<char> &dest);
@@ -77,14 +78,10 @@ namespace authdb {
    class User {
    public:
        void create(AuthBackend &backend,class UserData *dat);
        void remove(AuthBackend &backend,uuid_t uid);
        void remove(AuthBackend &backend,uuid_t *uid);

        void edit(AuthBackend &backend,uuid_t uid,class UserData &dat,size_t pos);
        void info(AuthBackend &backend,uuid_t uid,class UserData &dat,size_t pos);

        void getAdditional(AuthBackend &backend,uuid_t uid,struct AuthData &data,size_t pos);
        void remAdditional(AuthBackend &backend,uuid_t uid,const char *fieldname);
        void editAdditional(AuthBackend &backend,uuid_t uid,struct AuthData &data,const char *fieldname);
        void edit(AuthBackend &backend,uuid_t *uid,class UserData &dat,size_t &pos);
        void info(AuthBackend &backend,uuid_t *uid,class UserData &dat,size_t &pos);
    };

    class UserAPi{