path: root/src/Messaging/IMessage.cpp

//
// Tizen Web Device API
// Copyright (c) 2012 Samsung Electronics Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the License);
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include <pcrecpp.h>
#include <Commons/Exception.h>
#include "IMessage.h"
#include "EventSendMessage.h"
#include "EventMessagingService.h"
#include <Logger.h>

using namespace std;

namespace DeviceAPI {
namespace Messaging {

IMessage::IMessage(const MessageType msgType,
        const string& id) :
    m_id(id),
    m_convId(-1),
    m_msgType(msgType),
    m_readStatus(false),
    m_validReadStatus(false),
    m_isReadChangeStatus(false),
    m_validisReadChangeStatus(true),
    m_folder(DRAFTBOX),
    m_folderId(-1),
    m_requestReceiver(NULL),
    m_sendMessageEvent(NULL)
{
    LoggerD("message creation, msgId=" << m_id << ", msgType=" << m_msgType);

    //initialize dateTime of message
    time_t rawtime;
    time(&rawtime);
    tm* local = localtime(&rawtime);
    if (local) {
        m_dateTime = *local;
    } else {
        LoggerE("Failed to initialize message dateTime");
    }
}

IMessage::~IMessage()
{
    LoggerD("destroying message, msgId=" << m_id << ", msgType=" << m_msgType);
}

string IMessage::getId() const
{
    return m_id;
}

int IMessage::getConvId() const
{
    return m_convId;
}

const string& IMessage::getIdRef() const
{
    return m_id;
}

MessageType IMessage::getMessageType() const
{
    return m_msgType;
}

struct tm IMessage::getDateTime() const
{
    return m_dateTime;
}

string IMessage::convertId(int arg) const
{
    ostringstream stream;
    stream << arg;
    return stream.str();
}

int IMessage::convertId(const string& arg) const
{
    int retVal = 0;
    istringstream(arg) >> retVal;
    return retVal;
}

void IMessage::setId(const string& value)
{
    m_id = value;
}

void IMessage::setConvId(int value)
{
    m_convId = value;
}

void IMessage::setDateTime(const tm dateTime)
{
    m_dateTime = dateTime;
}

void IMessage::setReadStatus(bool state)
{
    m_validReadStatus = false;
    m_readStatus = state;
}

void IMessage::setSize(int size)
{
    m_size = size;
}

int IMessage::getSize() const
{
    return m_size;
}

bool IMessage::isRead() const
{
    return m_readStatus;
}

bool IMessage::isReadStatusValid() const
{
    return m_validReadStatus;
}

void IMessage::setReadStatusValidity(bool valid)
{
    m_validReadStatus = valid;
}

bool IMessage::isReadChangeStatus() const
{
    return m_isReadChangeStatus;
}

void IMessage::setisReadChangeStatus(bool state)
{
    m_validisReadChangeStatus = false;
    m_isReadChangeStatus = state;
}

bool IMessage::isReadChangeStatusValid() const
{
    return m_validisReadChangeStatus;
}

void IMessage::setisReadChangeStatusValidity(bool valid)
{
    m_validisReadChangeStatus = valid;
}

FolderType IMessage::getCurrentFolder() const
{
    return m_folder;
}

void IMessage::setFolderType(FolderType folder)
{
    m_folder = folder;
}

string IMessage::getCurrentUserFolder() const
{
    if (m_folder != USERDEFINED_FOLDER) {
        LoggerE("folder is not user folder type");
        Throw(WrtDeviceApis::Commons::UnknownException);
    }
    return m_userFolderName;
}

void IMessage::setCurrentUserFolder(const std::string& arg)
{
    m_userFolderName = arg;
}

int IMessage::getCurrentFolderId() const
{
    return m_folderId;
}

void IMessage::setCurrentFolderId(int folderId)
{
    m_folderId = folderId;
}


bool IMessage::validatePhoneNumber(std::string& number)
{
    LoggerD("testing number=" << number);
    return true;
/*
    pcrecpp::RE re("[^0-9#\\+\\*]?");
    re.GlobalReplace("", &number);	//remove invailde phone number. phone Number were composed only number.
    
    if (number.empty()) {
        LoggerE("wrong phoneNumber=" << number);
        return false;
    }
    LoggerD("phoneNumber=" << number);

    pcrecpp::RE re2("^[+#]?[0-9]{1,22}$");
    if (re2.FullMatch(number)) {
        LoggerD("vaildate Number=" << number);
        return true;
    }
    else
    {
        LoggerD("invaildate Number=" << number);
    	  return false;
    }
*/
}

bool IMessage::validateEmailAddr(const Recipients& addr)
{
    for (size_t i = 0; i < addr.getRecipientSize(); i++) {
        if (false == validateEmailAddr(addr.getRecipient(i))) {
            LoggerE("wrong email address");
            return false;
        }
    }
    return true;
}

bool IMessage::validateEmailAddr(const std::string& email)
{
    if (email.empty()) {
        return false;
    }
    pcrecpp::RE re(
        "^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}"
        "\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\"
        ".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$"
        );
    if (re.FullMatch(email)) {
        LoggerD("emailAddress=" << email);
        return true;
    }
    LoggerE("wrong emailAddress=" << email);
    return false;
}

void IMessage::setEmitter(const EventOnSendingFailedEmitterPtr& emitter)
{
    m_emitter = emitter;
}

EventOnSendingFailedEmitterPtr IMessage::getEmitter() const
{
    return m_emitter;
}

void IMessage::setSendMessageEvent(const EventSendMessagePtr &event)
{
    m_sendMessageEvent = event;
}

EventSendMessagePtr IMessage::getSendMessageEvent() const
{
    return m_sendMessageEvent;
}

void IMessage::setMessagingServiceEvent(const EventMessagingServicePtr & event)
{
	m_messagingServiceEvent = event;
}

EventMessagingServicePtr IMessage::getMessagingServiceEvent() const
{
	return m_messagingServiceEvent;
}

void IMessage::setRequestReceiver(ReqReceiverMessage* reqReceiver)
{
    m_requestReceiver = reqReceiver;
}

ReqReceiverMessage* IMessage::getRequestReceiver() const
{
    return m_requestReceiver;
}

void IMessage::setMessageStatus( MessageStatus status)
{
	LoggerD("setMessageStatus : " << status);
	m_msgStatus = status;
}

MessageStatus IMessage::getMessageStatus() const
{
	return m_msgStatus;
}

}
}