path: root/mobile_src/Messaging/Attachments.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 <algorithm>
#include <Commons/Exception.h>
#include "Attachments.h"
#include "AttachmentFactory.h"
#include <Logger.h>

extern "C" {
#include <sys/stat.h>
#include <stdlib.h>
}

using namespace WrtDeviceApis::Commons;
using namespace std;

//--------------------------------------------------------------------------
namespace DeviceAPI {
namespace Messaging {

Attachments::Attachments() :
    m_validAttachments(false)
{
    LoggerD("enter");
}

Attachments::~Attachments()
{
    LoggerD("enter");
}

IAttachmentPtr Attachments::appendAttachment(const std::string& fullPath,
        bool isVirtualPath)
{
    LoggerD("enter, fullPath=" << fullPath);
    IAttachmentPtr tmpAttach = AttachmentFactory::createAttachment(
            fullPath,
            isVirtualPath);
    m_validAttachments = false;
    m_attachments.push_back(tmpAttach);
    return tmpAttach;
}

void Attachments::appendAttachment(const IAttachmentPtr& attachment)
{
    LoggerD("enter");
    m_validAttachments = false;
    m_attachments.push_back(attachment);
}

void Attachments::appendInlineAttachment(const IAttachmentPtr& attachment)
{
    LoggerD("enter");
    m_validInineAttachments = false;
    m_inlineAttachments.push_back(attachment);
}

IAttachmentPtr Attachments::appendAttachment(const IMessagePtr& message, const std::string& fullPath,
		  bool isVirtualPath)
{
	LoggerD("enter");
	IAttachmentPtr iAttachment = appendAttachment(fullPath, isVirtualPath);

	if (message && iAttachment)
	{
		iAttachment->setMessage(message);
	}

	return iAttachment;
}

void Attachments::appendAttachment(const IMessagePtr& message, const IAttachmentPtr& attachment)
{
	LoggerD("enter");

    m_validAttachments = false;

    if (attachment && message)
		attachment->setMessage(message);
	
    m_attachments.push_back(attachment);
}

void Attachments::appendAttachments(const vector<IAttachmentPtr>& attachments)
{
    LoggerD("enter");
    back_insert_iterator< vector<IAttachmentPtr> >biit(m_attachments);
    copy(attachments.begin(), attachments.end(), biit);
}

size_t Attachments::getAttachmentsCount() const
{
    LoggerD("enter");
    return m_attachments.size();
}

size_t Attachments::getInlineAttachmentsCount() const
{
    LoggerD("enter");
    return m_inlineAttachments.size();
}

IAttachmentPtr Attachments::getAttachment(const size_t index) const
{
    LoggerD("enter");
    if (index >= m_attachments.size()) {
        ThrowMsg(OutOfRangeException, "Trying to get attachment out of range");
    }
    return m_attachments[index];
}

IAttachmentPtr Attachments::getInlineAttachment(const size_t index) const
{
    LoggerD("enter");
    if (index >= m_inlineAttachments.size()) {
        ThrowMsg(OutOfRangeException, "Trying to get attachment out of range");
    }
    return m_inlineAttachments[index];
}

void Attachments::removeAttachment(const size_t index)
{
    LoggerD("enter");
    if (index >= m_attachments.size()) {
        ThrowMsg(OutOfRangeException, "Trying to get attachment out of range");
    }
    m_validAttachments = false;
    m_attachments.erase(m_attachments.begin() + index);
}

void Attachments::removeAttachment(const IAttachmentPtr& attachment)
{
    m_attachments.erase(
        remove(m_attachments.begin(), m_attachments.end(), attachment),
        m_attachments.end());
}

vector<IAttachmentPtr> Attachments::getAttachments() const
{
    LoggerD("enter");
    return m_attachments;
}

vector<IAttachmentPtr> Attachments::getInlineAttachments() const
{
    LoggerD("enter");
    return m_inlineAttachments;
}

vector<string> Attachments::getAttachmentsFullPaths() const
{
    vector<string> retVal;

    for (size_t i = 0; i < m_attachments.size(); i++) {
        retVal.push_back(m_attachments[i]->getFullPath());
    }
    return retVal;
}

vector<string> Attachments::getAttachmentsShortNames() const
{
    vector<string> retVal;

    for (size_t i = 0; i < m_attachments.size(); i++) {
        retVal.push_back(m_attachments[i]->getShortName());
    }
    return retVal;
}

void Attachments::setAttachments(const vector<string>& attachments,
        bool isVirtualPath)
{
    vector<string>::const_iterator it = attachments.begin();

    m_attachments.clear();
    while (it != attachments.end()) {
        appendAttachment(*it, isVirtualPath);
        ++it;
    }
}

void Attachments::setAttachments(const vector<IAttachmentPtr>& attachments)
{
    m_attachments = attachments;
    m_validAttachments = false;
}

void Attachments::setInlineAttachments(const vector<IAttachmentPtr>& attachments)
{
    m_inlineAttachments = attachments;
    m_validInineAttachments = false;
}

bool Attachments::isAttachmentsValid() const
{
    LoggerD("m_validAttachments : " << m_validAttachments);
    return m_validAttachments;
}

void Attachments::setAttachmentsValidity(bool state)
{
    m_validAttachments = state;
}

bool Attachments::isInlineAttachmentsValid() const
{
    return m_validInineAttachments;
}

void Attachments::setInlineAttachmentsValidity(bool state)
{
    m_validInineAttachments = state;
}

const vector<IAttachmentPtr>& Attachments::getAttachmentsRef() const
{
    return m_attachments;
}

void Attachments::saveAttachment(const string& destFileName,
        const IAttachmentPtr& attachment)
{
    //  possible move it as a virtual function - to be clarified
    LoggerE("N/A");
    //TODO
}

void Attachments::setAttachmentWithExpand(const size_t index,
        const std::string& fullPath,
        bool isVirtualPath)
{
    // expand if needed
    if (index >= m_attachments.size()) {
        m_attachments.resize(index + 1);    // resize with empty ptr
    }
    IAttachmentPtr tmpAttach = AttachmentFactory::createAttachment(
            fullPath,
            isVirtualPath);
    m_attachments[index] = tmpAttach;
    m_validAttachments = false;
}

void Attachments::reverse()
{
    std::reverse(m_attachments.begin(), m_attachments.end());
}

void Attachments::insertAttachment(const size_t index,
        const std::string& fullPath,
        bool isVirtualPath)
{
    IAttachmentPtr tmpAttach = AttachmentFactory::createAttachment(
            fullPath,
            isVirtualPath);
    m_attachments.insert(m_attachments.begin() + index, tmpAttach);
    m_validAttachments = false;
}

void Attachments::insertAttachmentWithExpand(const size_t index,
        const std::string& fullPath,
        bool isVirtualPath)
{
    // expand if needed
    if (index >= m_attachments.size()) {
        m_attachments.resize(index);    // resize with empty ptr
    }
    IAttachmentPtr tmpAttach = AttachmentFactory::createAttachment(
            fullPath,
            isVirtualPath);
    m_attachments.insert(m_attachments.begin() + index, tmpAttach);
    m_validAttachments = false;
}
}
}