Commit c2ce7498 authored by jan.koester's avatar jan.koester
Browse files

user use templates

parent 769f520a
Loading
Loading
Loading
Loading
Loading
+1 −0
Changes for src/admin.cpp: 1 added line, 0 removed lines.
Original line number Diff line number Diff line
@@ -2151,6 +2151,7 @@ namespace authdb {
            libhtmlpp::HtmlString sendat;

            libhtmlpp::HtmlElement hform("form"),clist("ul");
            clist.setAttribute("id","clientcreateform");

            hform.setAttribute("method","post");
            hform.insertChild(clist);
+70 −0
Changes for src/authdb.h: 70 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <cstring>

#include <uuid/uuid.h>

#include "backend.h"
@@ -78,6 +80,74 @@ namespace authdb {
        friend    void delRecord(authdb::AuthBackend &backend,const uuid_t uid,int type);
    };

    template<class T,class Y>
    void setAuthData(int type,int storage,AuthData *dat,AuthData::Record **varclass,const char *varname,const Y *value,size_t count){
        AuthData::Record *target=*varclass;

        const AuthData *curec=dat;

        uuid_t gid;
        uuid_copy(gid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == type &&
                    uuid_compare(curec->Data->uuid,gid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

                    target=curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!target){
            AuthData::Record tmp;
            target=dat->append(tmp)->Data;
        }

        memset(target,0,sizeof(AuthData::Record));

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=type;
        target->storage=storage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize = sizeof(T)+(sizeof(Y)*count);
        target->data=new Y[target->datasize];
        memset(target->data,0,target->datasize);
        char *start =target->data;
        for(int i=0; i< count; ++i){
            memcpy(start+(sizeof(Y)*i),&value[i],sizeof(Y));
        }

        *varclass=target;
    }

    template<class T>
    inline const T *getAuthData(int type,int storage,const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->type==type && curdat->Data->storage==storage
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }

    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type);
    bool editRecord(AuthBackend &backend,AuthData &rec,int type);
+17 −0
Changes for src/client.cpp: 17 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -27,4 +27,21 @@

#include "client.h"

void authdb::ClientData::setClientKey(const Hash& key){
}

void authdb::ClientData::setName(const char* name){
}

void authdb::Client::create(AuthBackend& backend, class ClientData* data){

}

bool authdb::Client::exits(AuthBackend& backend, uuid_t* clid, const char* name, int& ret){
}

void authdb::Client::info(AuthBackend& backend, class ClientData& dat, size_t& pos){
}

void authdb::Client::remove(AuthBackend& backend, const uuid_t clid){
}
+6 −1
Changes for src/client.h: 6 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -41,9 +41,14 @@ namespace authdb {
    private:
        AuthData::Record *ClientName;
        AuthData::Record *ClientKey;
        friend class Client;
    };

    class Client {

    public:
        void create(AuthBackend &backend,class ClientData *data);
        void remove(AuthBackend &backend,const uuid_t clid);
        bool exits(AuthBackend&  backend, uuid_t* clid, const char* name,int &ret);
        void info(AuthBackend   &backend,class ClientData &dat,size_t &pos);
    };
};
+15 −116
Changes for src/user.cpp: 15 added lines, 116 removed lines.
Original line number Diff line number Diff line
@@ -28,70 +28,6 @@
#include "types.h"
#include "user.h"

namespace authdb {
    inline const char *getUserData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }

    inline void setUserData(AuthData *dat,AuthData::Record **varclass,const char *varname,const char *value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        uuid_t gid;
        uuid_copy(gid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::UserData &&
                    uuid_compare(curec->Data->uuid,dat->Data->uuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

                    target=curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
            target=*varclass;
        }

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=DataType::UserData;
        target->storage=StorageType::TextStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=strlen(value)+1;
        target->data= new char[target->datasize];
        strcpy(target->data,value);
    }

};



authdb::UserData::UserData(uuid_t id) : AuthData(id){
    username=nullptr;
    firstname=nullptr;
@@ -106,91 +42,54 @@ authdb::UserData::~UserData(){
}

void authdb::UserData::setFirstName(const char* src){
   setUserData(this,&firstname,"firstname",src);
   setAuthData<UserData,char>(DataType::UserData,StorageType::TextStorage,this,&firstname,"firstname",src, strlen(src)+1);
}

const char *authdb::UserData::getFirstname(){
    return getUserData(this,&firstname,"firstname");
    return getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&firstname,"firstname");
}


void authdb::UserData::setLastName(const char* src){
    setUserData(this,&lastname,"lastname",src);
    setAuthData<UserData,char>(DataType::UserData,StorageType::TextStorage,this,&lastname,"lastname",src,strlen(src)+1);
}

const char * authdb::UserData::getLastname(){
    return getUserData(this,&lastname,"lastname");
    return getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&lastname,"lastname");
}


void authdb::UserData::setMail(const char* src){
  setUserData(this,&mail,"mail",src);
    setAuthData<UserData,char>(DataType::UserData,StorageType::TextStorage,this,&mail,"mail",src,strlen(src)+1 );
}

const char *authdb::UserData::getMail(){
    return getUserData(this,&mail,"mail");
    return getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&mail,"mail");
}


void authdb::UserData::setPwHash(const char* src){
    setUserData(this,&pwhash,"pwhash",src);
    setAuthData<UserData,char>(DataType::UserData,StorageType::TextStorage,this,&pwhash,"pwhash",src,strlen(src)+1 );
}

#include <iostream>
const char * authdb::UserData::getPwHash(){
    return getUserData(this,&pwhash,"pwhash");
    std::cout << "test" <<std::endl;
    std::cout << getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&pwhash,"pwhash") << std::endl;
    return getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&pwhash,"pwhash");
}


void authdb::UserData::setUserName(const char* src){
    setUserData(this,&username,"username",src);
    setAuthData<UserData,char>(DataType::UserData,StorageType::TextStorage,this,&username,"username",src,strlen(src)+1);
}

const char * authdb::UserData::getUsername(){
    return getUserData(this,&username,"username");
    return getAuthData<char>(DataType::UserData,StorageType::TextStorage,this,&username,"username");
}

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

   AuthData *curec=this;

   uuid_t gid;
   uuid_copy(gid,Data->uuid);

   if(!target){
        while(curec){
            if(curec->Data->type == authdb::UserData &&
                uuid_compare(curec->Data->uuid,uid)==0 &&
                strcmp(curec->Data->fieldname,"avatar")==0
             ){

                target=curec->Data;
                target->datasize=0;
                delete[] target->data;
                target->data=nullptr;
                break;
            }
            curec=curec->next();
        }
    }

    if(!target){
      AuthData::Record newrec;
      target=append(newrec)->Data;
    }


    target->type=DataType::UserData;
    target->storage=StorageType::BinaryStorage;

    uuid_copy(target->uuid,gid);

    snprintf(target->fieldname,255,"%s","avatar");
    target->datasize=src.size();
    target->data= new char[target->datasize];
    memcpy(target->data,src.data(),target->datasize);

    avatar=target;
    setAuthData<UserData,char>(DataType::UserData,StorageType::BinaryStorage,this,
                                       &avatar,"avatar",src.data(),src.size());
}

void authdb::UserData::getAvatar(std::vector<char>& dest){