source: SMSSender/lib/libdatatypes/src/abstract/abstractaccount.cpp @ 71:415b45c71663

#include "abstractaccount.h"

AbstractAccount::AbstractAccount(IStorageOfficer* storageOfficer, IValidator* validator)
    : id_(-1)

    , enabled_(true)

    , freeSMSCount_(-1)

    , initializing_(false)
    , initialized_(false)
    , stoppingInitialization_(false)

    , cancelSMSSending_(false)
    , storageOfficer_(storageOfficer)
    , validator_(validator)
{
    eventMapper_ = new SAccountEventMapper(this);
}

SAccountEventMapper* AbstractAccount::eventMapper() const {
    return eventMapper_;
}
IAccountEvents* AbstractAccount::accountEvents() const {
    return static_cast<IAccountEvents*>(eventMapper());
}


int AbstractAccount::id() const {
    return id_;
}
void AbstractAccount::setId(int id) {
    if (id_ == id) return;

    int oldId = id_;
    id_ = id;

    emit accountEvents()->idChanged(oldId, id);
    emit accountEvents()->dataChanged();
}

QString AbstractAccount::name() const {
    return name_;
}
void AbstractAccount::setName(const QString& name) {
    SET_IF_DIFFERENT(name_, name.trimmed());
    emit accountEvents()->dataChanged();
}


void AbstractAccount::setStatus(const QString& status, int progress /* = -1 */, const ProgressMethod& progressMethod /* = SetProgress*/) {
    if (status_ != status) {
        status_ = status;

        emit accountEvents()->statusChanged(status);
    }

    if (progress > -1) {
        setProgress(progress, progressMethod);
    }
}
void AbstractAccount::setProgress(int progress, const ProgressMethod& progressMethod /* = SetProgress */) {
    switch (progressMethod) {
        case IncProgress:
            progress_ += progress;
            break;

        case SetProgress:
            SET_IF_DIFFERENT(progress_, progress);
            break;
    }

    emit accountEvents()->progressChanged(progress_);
}

bool AbstractAccount::isEnabled() const {
    return enabled_;
}
void AbstractAccount::setEnabled(bool enabled) {
    SET_IF_DIFFERENT(enabled_, enabled);
    emit accountEvents()->dataChanged();

    if (!enabled) {
        unInitialize();
    }
}


int AbstractAccount::freeSMSCount() const {
    return freeSMSCount_;
}
void AbstractAccount::setFreeSMSCount(int freeSMSCount) {
    SET_IF_DIFFERENT(freeSMSCount_, freeSMSCount);
    emit accountEvents()->dataChanged();
}

IValidator* AbstractAccount::getValidator() const {
    return validator_;
}
IStorageOfficer* AbstractAccount::getStorageOfficer() const {
    return storageOfficer_;
}



void AbstractAccount::initialize(){
    if (isInitializing() || isInitialized() || !isEnabled()) {
        return;
    }

    /* TODO: Do this in a queue... */

    while (stoppingInitialization_){
        // TODO: sleep...
    }

    initializing_ = true;
    try{
        doInitialize();

        if (!stoppingInitialization_)
            setInitialized(true);
    }catch (...) {
        initializing_ = false;
        throw;
    }
    initializing_ = false;
    stoppingInitialization_ = false;
}

void AbstractAccount::stopInitializing() {
    if (isInitializing())
        stoppingInitialization_ = true;
}

bool AbstractAccount::isInitializing() {
    return initializing_;
}

bool AbstractAccount::isInitialized() {
    return initialized_;
}

void AbstractAccount::setInitialized(bool initialized) {
    SET_IF_DIFFERENT(initialized_, initialized);
    emit accountEvents()->dataChanged();
}


void AbstractAccount::unInitialize() {
    if (isInitializing())
        stopInitializing();

    setInitialized(false);
}


void AbstractAccount::cancelSMSSending() {
    cancelSMSSending_ = true;
}

bool AbstractAccount::isSendingCanceled() {
    return cancelSMSSending_;
}

void AbstractAccount::uncancelSendingSMS() {
    cancelSMSSending_ = false;
}