/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implements the functions to manipulate the Podcast table

*

*/

// INCLUDE FILES

#include <PCRes.rsg>

#include <sqldb.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxpodcastdefs.h>

#include <mpxlog.h>

#include "mpxdbcommondef.h"

#include "mpxdbcommonstd.h"

#include "mpxresource.h"

#include "mpxdbcommonutil.h"

#include "mpxdbmanager.h"

#include "mpxdbutil.h"

#include "mpxpodcastcollectiondbdef.h"

#include "mpxpodcastdbpluginqueries.h"

#include "mpxdbpodcast.h"

//CONSTANTS

// UniqueID column in Uris requests

const TInt KColUniqueID = 0;

// URI column in Uris requests

const TInt KColUri = 1;

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXDbPodcast* CMPXDbPodcast::NewL(

    CMPXDbManager& aDbManager,

    CMPXResource& aResource,

    MMPXDbPodcastObserver& aObserver)

    {

    MPX_FUNC("CMPXDbPodcast::NewL");

    CMPXDbPodcast* self = CMPXDbPodcast::NewLC(aDbManager, aResource, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXDbPodcast* CMPXDbPodcast::NewLC(

    CMPXDbManager& aDbManager,

    CMPXResource& aResource,

    MMPXDbPodcastObserver& aObserver)

    {

    MPX_FUNC("CMPXDbPodcast::NewLC");

    CMPXDbPodcast* self = new (ELeave) CMPXDbPodcast(aDbManager, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aResource);

    return self;

    }

// ----------------------------------------------------------------------------

// Destructor.

// ----------------------------------------------------------------------------

//

CMPXDbPodcast::~CMPXDbPodcast()

    {

    MPX_FUNC("CMPXDbPodcast::~CMPXDbPodcast");

    delete iExtensionsDrm;

    }

// ----------------------------------------------------------------------------

// Constructor

// ----------------------------------------------------------------------------

//

CMPXDbPodcast::CMPXDbPodcast(

    CMPXDbManager& aDbManager,

    MMPXDbPodcastObserver& aObserver) :

    CMPXDbTable(aDbManager),

    iObserver(aObserver)

    {

    MPX_FUNC("CMPXDbPodcast::CMPXDbPodcast");

    }

// ----------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::ConstructL(

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXDbPodcast::ConstructL");

    BaseConstructL();

    iExtensionsDrm = aResource.ReadDesCArrayL(R_MC_FILE_EXTENSIONS_DRM);

    }

// ----------------------------------------------------------------------------

// Add a episode to the podcast table

// ----------------------------------------------------------------------------

//

TUint32 CMPXDbPodcast::AddEpisodeL(

    const CMPXMedia& aMedia,

    TInt aDrive)

    {

    MPX_FUNC("CMPXDbPodcast::AddEpisodeL");

    if (!aMedia.IsSupported(KMPXMediaGeneralUri))

        {

        User::Leave(KErrArgument);

        }

    TUint32 episodeId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection,

        aMedia.ValueText(KMPXMediaGeneralUri), EFalse));

    if (EpisodeExistsL(episodeId))

        {

        DoUpdateEpisodeL(episodeId, aMedia, NULL);

        }

    else

        {

        // add the song

        DoAddEpisodeL(episodeId, aMedia, aDrive, NULL);

        }

    return episodeId;

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::UpdateEpisodeL

// ----------------------------------------------------------------------------

//

CMPXDbActiveTask::TChangeVisibility CMPXDbPodcast::UpdateEpisodeL(

    TUint32 aEpisodeId,

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::UpdateEpisodeL");

    return DoUpdateEpisodeL(aEpisodeId, aMedia, &aItemChangedMessages);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::CleanupL

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::CleanupL()

    {

    MPX_FUNC("CMPXDbPodcast::CleanupL");

    iDbManager.ExecuteQueryL(KDbManagerAllDrives, KQueryPodcastCleanup);

    }

// ----------------------------------------------------------------------------

// Remove a episode from the podcast table

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteEpisodeL(

    TUint32 aEpisodeId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages,

    TBool aDeleteRecord)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteEpisodeL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetEpisode,

        aEpisodeId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    DoDeleteEpisodeL(recordset, aUriArray, aItemChangedMessages, aDeleteRecord);

    CleanupStack::PopAndDestroy(&recordset);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::DeleteCategoryL

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteCategoryL(

    TMPXGeneralCategory aCategory,

    TUint32 aCategoryId,

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteCategoryL");

    TPtrC ptr(MPXDbUtil::PodcastFieldNameForCategoryL(aCategory));

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastCategory,

        &ptr, aCategoryId));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published today

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteTodayEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteTodayEpisodesL");

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastToday, now, now));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published yesterday

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteYesterdayEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteYesterdayEpisodesL");

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastYesterday, now, now));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published this week

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteThisWeekEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteThisWeekEpisodesL");

    TInt dayNo(MPXDbUtil::DayNoInWeek());

    dayNo++; // shifted by 1 day to get correct results

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween,

        now, dayNo, now, 1));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published last week

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteLastWeekEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteLastWeekEpisodesL");

    TInt dayNo(MPXDbUtil::DayNoInWeek());

    dayNo++; // shifted by 1 day to get correct results

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween,

        now, dayNo + 7, now, dayNo));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published 2 weeks ago

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::Delete2WeeksAgoEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::Delete2WeeksAgoEpisodesL");

    TInt dayNo(MPXDbUtil::DayNoInWeek());

    dayNo++; // shifted by 1 day to get correct results

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween,

        now, dayNo + 14, now, dayNo + 7));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published 3 weeks ago

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::Delete3WeeksAgoEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::Delete3WeeksAgoEpisodesL");

    TInt dayNo(MPXDbUtil::DayNoInWeek());

    dayNo++; // shifted by 1 day to get correct results

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween,

        now, dayNo + 21, now, dayNo + 14));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published last month

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteLastMonthEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteLastMonthEpisodesL");

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastLastMonth, now, now));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that are published earlier

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteEarlierEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteEarlierEpisodesL");

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastEarlier, now));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Remove all podcast episodes from the podcast table that do not have a published date

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::DeleteUnknownEpisodesL(

    CDesCArray& aUriArray,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPodcast::DeleteUnknownEpisodesL");

    HBufC* now = MPXDbCommonUtil::CurrentDateDesLC();

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastUnknown, now));

    CleanupClosePushL(recordset);

    DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages);

    CleanupStack::PopAndDestroy(&recordset);

    CleanupStack::PopAndDestroy(now);

    }

// ----------------------------------------------------------------------------

// Get the episode Id and duration

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::EpisodeDurationL(

    TUint32 aEpisodeId)

    {

    MPX_FUNC("CMPXDbPodcast::EpisodeDurationL");

    return ExecuteSumQueryL(KQueryPodcastEpisodeDuration, aEpisodeId);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::AllEpisodesDurationL

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::AllEpisodesDurationL()

    {

    MPX_FUNC("CMPXDbPodcast::AllEpisodesDurationL");

    return ExecuteSumQueryL(KQueryPodcastDurationAll);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::TitleDurationL

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::TitleDurationL(

    TUint32 aTitleId)

    {

    MPX_FUNC("CMPXDbPodcast::TitleDurationL");

    return ExecuteSumQueryL(KQueryPodcastDurationAlbum, aTitleId);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::NotPlayedDurationL

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::NotPlayedDurationL()

    {

    MPX_FUNC("CMPXDbPodcast::NotPlayedDurationL");

    return ExecuteSumQueryL(KQueryPodcastNotPlayedDuration);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::RecentlyAddedDurationL

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::RecentlyAddedDurationL()

    {

    MPX_FUNC("CMPXDbPodcast::RecentlyAddedDurationL");

    return ExecuteSumQueryL(KQueryPodcastRecentlyAddedDuration);

    }

// ----------------------------------------------------------------------------

// Get the name of the episode matching the given ID

// ----------------------------------------------------------------------------

//

HBufC* CMPXDbPodcast::GetNameL(

    TUint32 aEpisodeId)

    {

    MPX_FUNC("CMPXDbPodcast::GetNameL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetTitle,

        aEpisodeId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    HBufC* name =  recordset.ColumnTextL(KMPXTableDefaultIndex).AllocL();

    CleanupStack::PopAndDestroy(&recordset);

    return name;

    }

// ----------------------------------------------------------------------------

// Get URI of the episode

// ----------------------------------------------------------------------------

//

HBufC* CMPXDbPodcast::GetUriL(

    TUint32 aEpisodeId)

    {

    MPX_FUNC("CMPXDbPodcast::GetUriL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetEpisodeNoCat,

        aEpisodeId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    HBufC* uri = ConstructUriL(recordset);

    CleanupStack::PopAndDestroy(&recordset);

    return uri;

    }

// ----------------------------------------------------------------------------

// Find the drive Ids of corresponding unique Episode Id

// ----------------------------------------------------------------------------

//

TInt CMPXDbPodcast::GetDriveL(

    TUint32 aEpisodeId)

    {

    MPX_FUNC("CMPXDbPodcast::GetDriveL");

    return MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

        ExecuteIntQueryL(KQueryPodcastVolume, aEpisodeId));

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::GetEpisodeL

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::GetEpisodeL(

    TUint32 aEpisodeId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbPodcast::GetEpisodeL");

    ExecuteMediaQueryL(aAttrs, aMedia, ExtraFieldsRequired(aAttrs) ?

        KQueryPodcastGetEpisode() : KQueryPodcastGetEpisodeNoCat(), aEpisodeId);

    }

// ----------------------------------------------------------------------------

// CMPXDbPodcast::GetAllEpisodesL

// ----------------------------------------------------------------------------

//

void CMPXDbPodcast::GetAllEpisodesL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbPodcast::GetAllEpisodesL");

    ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ?

        KQueryPodcastGetAllEpisodes() : KQueryPodcastGetAllEpisodesNoCat());

    }