Song & MagnatuneService::fixPath(Song &s) const
{
s.type=Song::OnlineSvrTrack;
if (MB_None!=membership) {
QUrl url;
#if QT_VERSION < 0x050000
url.setEncodedUrl(s.file.toLocal8Bit());
#else
url=QUrl(s.file);
#endif
url.setScheme("http");
url.setHost(MB_Streaming==membership ? constStreamingHostname : constDownloadHostname);
url.setUserName(username);
url.setPassword(password);
// And remove the commercial
QString path = url.path();
path.insert(path.lastIndexOf('.'), "_nospeech");
url.setPath(path);
s.file=url.toString();
// TODO: Magnatune downloads!
// if (MB_Download==membership) {
// s.genre=downloadTypeStr(download);
// }
}
s.setIsFromOnlineService(name());
return encode(s);
}
QUrl
SeriesAction::replaceModifiers(QUrl url, QtTvDB::Show *show,
int season, QtTvDB::Episode *episode) const
{
/*
* %S current show name (MyShow)
* %E current episode name (Pilot)
* %n current season number (1)
* %e current episode number (1)
* %b formated episode number (E01)
* %m formated season number (S01)
*/
QString str = url.toString();
if (show) {
str.replace("%S", QUrl::toPercentEncoding(show->name()));
}
if (season >= 0) {
str.replace("%n", QUrl::toPercentEncoding(QString("%1").arg(season)));
str.replace("%m", QUrl::toPercentEncoding(QString("S%1").arg(season, 2, 10, QLatin1Char('0'))));
}
if (episode) {
str.replace("%E", QUrl::toPercentEncoding(episode->name()));
str.replace("%e", QUrl::toPercentEncoding(QString("%1").arg(episode->episode())));
str.replace("%b", QUrl::toPercentEncoding(QString("E%1").arg(episode->episode(), 2, 10, QLatin1Char('0'))));
}
QUrl ret;
ret.setEncodedUrl(str.toUtf8());
return ret;
}
void CFileDownload::download(const QString& strUrl, const QString& strFolder, bool bOverWrite, bool bAutoRemoveFile)
{
m_strFolder = strFolder;
m_strUrl = strUrl;
m_bOverWrite = bOverWrite;
m_bAutoRemoveFile = bAutoRemoveFile;
QUrl url;
url.setEncodedUrl(m_strUrl.toAscii());
if (!url.isValid())
{
emit finishedDownloadAttachmentItem(m_pAttachmentItem, tr("Error: Bad file URL"));
return;
}
if(m_pAttachmentItem)
m_pAttachmentItem->setProcessState(STATE_PS_UPLOADING);
QNetworkRequest request(url);
request.setRawHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)");
// request.setRawHeader("User-Agent", "Wget");
// request.setRawHeader("Accept", "*/*");
// request.setRawHeader("Connection", "Keep-Alive");
// request.setRawHeader("Keep-Alive", "300");
m_pNetworkReply = m_pNetworkMgr->get(request);
connect(m_pNetworkReply, SIGNAL(metaDataChanged()), this, SLOT(onMetaDataChanged()));
connect(m_pNetworkReply, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
connect(m_pNetworkReply, SIGNAL(uploadProgress(qint64, qint64)), this, SIGNAL(uploadProgress(qint64, qint64)));
connect(m_pNetworkReply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(onDownloadProgress(qint64,qint64)));
connect(m_pNetworkReply, SIGNAL(finished()), this, SLOT(onFinished()));
}
int Url::setEncodedUrl ( lua_State * L )// ( const QByteArray & encodedUrl )
{
QUrl* lhs = ValueInstaller2<QUrl>::check( L, 1 );
//QByteArray* encodedUrl = ValueInstaller2<QByteArray>::check( L, 2 );
if( Util::isNil( L, 3 ))
{
lhs->setEncodedUrl( Util::toStr( L, 2 ) );
}
else
{
Enums enums(L);
QUrl::ParsingMode f=(QUrl::ParsingMode)enums.ParsingMode( 3 );
lhs->setEncodedUrl( Util::toStr( L, 2 ), f );
}
return 0;
}
void UBOEmbedParser::onParseContent(QString url)
{
QUrl qurl;
qurl.setEncodedUrl(url.toAscii());
QNetworkRequest req;
req.setUrl(qurl);
if(NULL != mpNam) {
mpNam->get(req);
}
}
void CWizGroupAttributeForm::on_clientLoginDone()
{
QString strExt = QString("token=%1&kb_guid=%2").arg(WizGlobal()->token()).arg(m_strKbGUID);
QByteArray bytes = QUrl::toPercentEncoding(strExt);
QString strUrl = WizApiGetUrl("wiz", WIZ_CLIENT_VERSION, "view_group", bytes);
// use raw url
QUrl url;
url.setEncodedUrl(strUrl.toAscii());
m_web->load(url);
}
/*
void VDomKit::start()
{
connect(m_page, SIGNAL(loadFinished(bool)), this, SLOT(load()));
}
*/
const QByteArray& VDomKit::dump(const QByteArray &url) {
QUrl qurl;
qurl.setEncodedUrl(url, QUrl::StrictMode);
//qDebug() << qurl << endl;
if (qurl.isValid()) {
#ifdef ENABLE_TIMER
QTime t;
t.start();
#endif
m_page->mainFrame()->load(qurl);
VDomKitLoop loop;
QObject::connect(m_page, SIGNAL(loadFinished(bool)), &loop,
SLOT(quitWithRes(bool)));
QTimer timer;
QSignalSpy timeoutSpy(&timer, SIGNAL(timeout()));
if (m_timeout > 0) {
QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
timer.setSingleShot(true);
timer.start(m_timeout);
}
loop.exec();
if (!timeoutSpy.isEmpty()) {
fprintf(stderr, "Page loading timeout (exceeded %d ms): %s\n",
m_timeout, url.data());
m_page->blockSignals(true);
m_page->triggerAction(QWebPage::Stop);
m_page->blockSignals(false);
//return NullString;
} else if (!loop.getRes()) {
fprintf(stderr, "Failed to load page: %s\n", url.data());
return NullString;
}
#ifdef ENABLE_TIMER
qDebug("loading elapsed: %d ms", t.elapsed());
t.restart();
#endif
const QByteArray& retval = m_webvdom->dump();
#ifdef ENABLE_TIMER
qDebug("dumping elapsed: %d ms", t.elapsed());
#endif
return retval;
} else {
Song MagnatuneService::ReadTrack(QXmlStreamReader& reader) {
Song song;
while (!reader.atEnd()) {
reader.readNext();
if (reader.tokenType() == QXmlStreamReader::EndElement) break;
if (reader.tokenType() == QXmlStreamReader::StartElement) {
QStringRef name = reader.name();
QString value = ReadElementText(reader);
if (name == "artist") song.set_artist(value);
if (name == "albumname") song.set_album(value);
if (name == "trackname") song.set_title(value);
if (name == "tracknum") song.set_track(value.toInt());
if (name == "year") song.set_year(value.toInt());
if (name == "magnatunegenres") song.set_genre(value.section(',', 0, 0));
if (name == "seconds")
song.set_length_nanosec(value.toInt() * kNsecPerSec);
if (name == "cover_small") song.set_art_automatic(value);
if (name == "albumsku") song.set_comment(value);
if (name == "url") {
QUrl url;
// Magnatune's URLs are already encoded
url.setEncodedUrl(value.toLocal8Bit());
url.setScheme("magnatune");
song.set_url(url);
}
}
}
song.set_valid(true);
song.set_filetype(Song::Type_Stream);
// We need to set these to satisfy the database constraints
song.set_directory_id(0);
song.set_mtime(0);
song.set_ctime(0);
song.set_filesize(0);
return song;
}
QNetworkReply* QCouch::doRequest(Method method, QString _url, const QByteArray bytes){
QUrl url = QUrl();
url.setEncodedUrl(QString(host + _url).toUtf8());
url.setPort(port);
QTimer timeout;
QEventLoop loop;
timeout.setSingleShot(true);
QNetworkRequest request;
request.setUrl(url);
QNetworkReply *reply;
switch (method) {
case GET:
reply = manager->get(request);
break;
case PUT:
reply = manager->put(request, bytes);
break;
case DELETE:
reply = manager->deleteResource(request);
break;
default:
reply = manager->get(request);
break;
}
QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
QObject::connect(&timeout, SIGNAL(timeout()), &loop, SLOT(quit()));
timeout.start(5000);
loop.exec();
if ( timeout.isActive() ) {
return reply;
} else {
throw new TimeoutException;
}
}
QUrl Oauth::createOAuthUrl( const QUrl url, const QString oAuthConsumerKey, const QString sharedSecret, const QString verb , const QString tokenSecret )
{
const QString current = QString::number(QDateTime::currentDateTime().toUTC().toTime_t());
const QString nonce = Nonce();
QList<QPair<QString, QString> > inputParams = url.queryItems();
inputParams.append(QPair<QString,QString>(QString::fromLatin1(OAUTH_CONSUMER_KEY),oAuthConsumerKey));
inputParams.append(QPair<QString,QString>(QString::fromLatin1(OAUTH_SIGNATURE_METHOD),NETFLIX_SIGNATURE_METHOD));
inputParams.append(QPair<QString,QString>(QString::fromLatin1(OAUTH_TIMESTAMP),current));
inputParams.append(QPair<QString,QString>(QString::fromLatin1(OAUTH_NONCE),nonce));
inputParams.append(QPair<QString,QString>(QString::fromLatin1(OAUTH_VERSION),NETFLIX_OAUTH_VERSION));
qSort(inputParams.begin(),inputParams.end(),comparer);
qDebug() << inputParams;
QByteArray host = url.toEncoded(QUrl::RemoveQuery);
QUrl returnUrl;
returnUrl.setEncodedUrl(host);
const int length = inputParams.size();
for( int i=0; i<length ; i++)
{
returnUrl.addQueryItem(inputParams.at(i).first,inputParams.at(i).second);
}
QString oAuthParams = returnUrl.encodedQuery();
QString requestString = QString("%1&%2&%3").arg(verb, host.toPercentEncoding(), Escape(oAuthParams));
qDebug() << requestString;
QByteArray signature = HmacSha1(sharedSecret,requestString, tokenSecret);
qDebug() << signature;
returnUrl.addEncodedQueryItem(OAUTH_SIGNATURE,signature);
return returnUrl;
}
QUrl LastFMService::FixupUrl(const QUrl& url) {
QUrl ret;
ret.setEncodedUrl(url.toEncoded().replace(
"USERNAME", QUrl::toPercentEncoding(lastfm::ws::Username)));
return ret;
}
bool WulforUtil::openUrl(const QString &url){
if (url.startsWith("http://") || url.startsWith("www.") || url.startsWith(("ftp://")) || url.startsWith("https://")){
if (!SETTING(MIME_HANDLER).empty())
QProcess::startDetached(_q(SETTING(MIME_HANDLER)), QStringList(url));
else
QDesktopServices::openUrl(QUrl::fromEncoded(url.toAscii()));
}
else if (url.startsWith("adc://") || url.startsWith("adcs://")){
MainWindow::getInstance()->newHubFrame(url, "UTF-8");
}
else if (url.startsWith("dchub://")){
MainWindow::getInstance()->newHubFrame(url, WSGET(WS_DEFAULT_LOCALE));
}
else if (url.startsWith("magnet:") && url.contains("urn:tree:tiger")){
QString magnet = url;
Magnet *m = new Magnet(MainWindow::getInstance());
m->setLink(magnet);
if (WIGET(WI_DEF_MAGNET_ACTION) == 0) {
m->exec();
}
m->deleteLater();
}
else if (url.startsWith("magnet:")){
QString magnet = url;
QUrl u;
if (!magnet.contains("+"))
u.setEncodedUrl(magnet.toAscii());
else {
QString _l = magnet;
_l.replace("+", "%20");
u.setEncodedUrl(_l.toAscii());
}
if (u.hasQueryItem("kt")){
QString keywords = u.queryItemValue("kt");
QString hub = u.hasQueryItem("xs")? u.queryItemValue("xs") : "";
if (!(hub.startsWith("dchub://", Qt::CaseInsensitive) ||
hub.startsWith("adc://", Qt::CaseInsensitive) ||
hub.startsWith("adcs://", Qt::CaseInsensitive)) && !hub.isEmpty())
hub.prepend("dchub://");
if (keywords.isEmpty())
return false;
if (!hub.isEmpty())
WulforUtil::openUrl(hub);
SearchFrame *sfr = ArenaWidgetFactory().create<SearchFrame>();
sfr->fastSearch(keywords, false);
}
else {
if (!SETTING(MIME_HANDLER).empty())
QProcess::startDetached(_q(SETTING(MIME_HANDLER)), QStringList(url));
else
QDesktopServices::openUrl(QUrl::fromEncoded(url.toAscii()));
}
}
else
return false;
return true;
}
void QUrlProto::setEncodedUrl(const QByteArray &encodedUrl, QUrl::ParsingMode parsingMode)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedUrl(encodedUrl, parsingMode);
}
