Commit 34e2c033 authored by jan.koester's avatar jan.koester
Browse files

edit user implemented

parent 5da197ed
Loading
Loading
Loading
Loading
+206 −2
Changes for src/authdb.cpp: 206 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -25,9 +25,11 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <algorithm>
#include <iostream>
#include <cstring>
#include <sstream>
#include <map>

#include <uuid/uuid.h>
#include <cmdplus/cmdplus.h>
@@ -143,7 +145,7 @@ namespace authdb {

                        std::vector<char> tmp;
                        if(strcmp(curdispo->getValue(),"avatar")!=0){
                            std:copy(curformdat->Value.begin(),curformdat->Value.end(),std::back_inserter(tmp));
                            std::copy(curformdat->Value.begin(),curformdat->Value.end(),std::back_inserter(tmp));
                            tmp.push_back('\0');
                        }

@@ -263,6 +265,130 @@ namespace authdb {
            _Backend.unlock();
        };

        void editUser(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            _Backend.lock();
            size_t rd=sizeof(authdb::AuthHeader),end=_Backend.end();
            char cuid[255];

            sscanf(curreq->getRequestURL(),"/admin/edituser/%s",cuid);

            AuthDataRecord editrec,*curec=&editrec;

            bool data = false;

            libhttppp::HttpForm curform;

            curform.parse(curreq);

            for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
                    curformdat; curformdat = curformdat->nextData()) {
                    for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                        curdispo; curdispo=curdispo->nextContentDisposition()
                    ){
                        if(curformdat->Value.empty() || !curdispo->getValue())
                            continue;

                        data = true;

                        strcpy(curec->Data->uuid,cuid);

                        curec->Data->type=UserData;
                        curec->Data->storage=TextStorage;

                        for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                            curdispo; curdispo=curdispo->nextContentDisposition()
                        ){

                            std::string key;

                            if(curdispo->getKey())
                                key=curdispo->getKey();

                            std::transform(key.begin(), key.end(), key.begin(),
                                            [](unsigned char c){ return std::tolower(c); });

                            if(key=="name"){
                                strcpy(curec->Data->fieldname,curdispo->getValue());
                            }else if(key=="content-type" && strncmp(curdispo->getValue(),"text/",5) != 0){
                                curec->Data->storage=BinaryStorage;
                            }
                        }

                        curec->Data->datasize=curformdat->Value.size();
                        curec->Data->data=new char[curec->Data->datasize];
                        memcpy(curec->Data->data,curformdat->Value.data(),curformdat->Value.size());
                    }
                    if(curformdat->nextData()){
                            curec->_next=new AuthDataRecord;
                            curec=curec->_next;
                    }
            }

            uuid_t uid;
            uuid_parse(cuid,uid);

            if(data){
                editRecord(_Backend,&editrec,uid,UserData);
                _Backend.unlock();
                libhttppp::HttpResponse rep;
                rep.setState(HTTP307);
                rep.setVersion(HTTPVERSION(1.1));
                rep.setHeaderData("Location")->push_back("/admin/listusers");
                rep.setContentType("text/html");
                rep.send(curreq,nullptr,0);
                return;
            }
            libhtmlpp::HtmlPage page;

            libhtmlpp::HtmlString form,out;

            form  << "<form method=\"post\" enctype=\"multipart/form-data\">"
                  << "<table>";

            while(rd<end){
                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->uuid,cuid)==0 /*&& cur->type==UserData*/ && cur->storage==TextStorage){
                    try {
                        form  << "<tr><td><label for=\"username\">" << cur->fieldname << "</label></td>"
                              << "<td><input type=\"text\" name=\"" << cur->fieldname << "\" value=\""
                              << cur->data <<"\"></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                }

                delete[] cur->data;
                delete cur;
            }
            _Backend.unlock();

            form  << "<tr><td><label for=\"avatar\">ProfilBild:</label></td>"
                  << "<td><input type=\"file\" name=\"avatar\"></td></tr>"
                  << "<tr><td></td><td><input type=\"submit\"></td></tr>"
                  << "</table>"
                  << "</form";

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

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

            libhtmlpp::print(&root,out,true);

            libhttppp::HttpResponse rep;
            rep.setContentType("text/html");
            rep.setContentLength(out.size());
            rep.send(curreq,out.c_str(),out.size());
        }

        void AdminController(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            if(strncmp(curreq->getRequestURL(),"/admin/listusers",16)==0){
                listUsers(curreq,tid,args);
@@ -270,6 +396,8 @@ namespace authdb {
                createUser(curreq,tid,args);
            }else if(strncmp(curreq->getRequestURL(),"/admin/removeuser",17)==0){
                removeuser(curreq,tid,args);
            }else if(strncmp(curreq->getRequestURL(),"/admin/edituser",15)==0){
                editUser(curreq,tid,args);
            }else if(strncmp(curreq->getRequestURL(),"/admin/getavatar/",17)==0){
                getAvatar(curreq,tid,args);
            }else{
@@ -350,7 +478,7 @@ VALUEFOUND:
    };


    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,uuid_t id,int type){
    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type){
        bool found=false;
        AuthData *cur=new AuthData;
        int rd=sizeof(authdb::AuthHeader),end=backend.end();
@@ -381,6 +509,82 @@ VALUEFOUND:
        return found;
    }

    bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type){
        AuthDataRecord old;

        std::vector<AuthData*> changemap; //use fieldname;
        std::vector<AuthData*> newmap;

        getRecord(backend,&old,uid,type);

        for(const AuthDataRecord *curdat=rec; curdat; curdat=curdat->_next){
            bool newentry=true;
            for(const AuthDataRecord *olddat=&old; olddat; olddat=olddat->_next){
                if(strcmp(olddat->Data->uuid,curdat->Data->uuid)==0
                    && strcmp(olddat->Data->fieldname,curdat->Data->fieldname)==0
                ){
                    size_t end = olddat->Data->datasize;
                    if(end!=curdat->Data->datasize){
                        changemap.push_back(curdat->Data);
                    }else{
                        for(size_t i=0; i<end; ++i){
                            if(olddat->Data->data[i]!=curdat->Data->data[i]){
                                changemap.push_back(curdat->Data);
                                break;
                            }
                        }
                    }
                    newentry=false;
                }
            }

            if(newentry){
                newmap.push_back(curdat->Data);
            }

        }

        for(auto newel : newmap){
            backend.WriteAuthData(newel,backend.end());
            backend.setPos(backend.end());
            backend.write((const unsigned char*)newel->data,newel->datasize);
        }

        char cuid[255];
        const unsigned char zero = 0;

        uuid_unparse(uid,cuid);

        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
            while(rd<end){
                authdb::AuthData *rdrec=new AuthData;
                backend.ReadAuthData(rdrec,rd);
                if(strcmp(rdrec->uuid,cuid)==0 && strcmp(rdrec->fieldname,chel->fieldname)==0){
                    backend.WriteAuthData(chel,backend.end());
                    backend.write((const unsigned char*)chel->data,chel->datasize);
                    size_t dsize=rdrec->datasize;
                    memset(rdrec,0,sizeof(AuthData));
                    rdrec->start=0xFE;
                    rdrec->datasize=dsize;
                    rdrec->end=0xFF;
                    backend.WriteAuthData(rdrec,rd);
                    for(size_t i =0; i<rdrec->datasize; ++i){
                        backend.write(&zero,1);
                    }
                    rd=backend.getPos();
                }else{
                    rd=backend.getPos()+rdrec->datasize;
                }
                delete rdrec;
            }
        }

        if(!changemap.empty() || !newmap.empty())
            return true;
        return false;
    }

    void delRecord(AuthBackend &backend,const uuid_t uid){
        size_t end=backend.end(),rd=sizeof(AuthHeader);

+4 −2
Changes for src/authdb.h: 4 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -66,10 +66,12 @@ namespace authdb {
        AuthData *Data;

        AuthDataRecord    *_next;
        friend bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,uuid_t id,int type);
        friend bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type);
        friend bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type);
        friend void delRecord(AuthBackend &backend,const uuid_t uid);
    };

    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,uuid_t id,int type);
    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type);
    bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type);
    void delRecord(authdb::AuthBackend &backend,const uuid_t uid);
};