void MusicXMLConfigManager::writeMusicSongsConfig(const MusicSongsList &musics)
{
if( musics.isEmpty() )
{
return;
}
//Open wirte file
if( !writeConfig(MUSICPATH_AL) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("TTKMusicPlayer");
//Class A
QDomElement fileNormalPath = writeDomElement(musicPlayer, "fileNormalPath", "count", musics[0].count());
QDomElement fileLovestPath = writeDomElement(musicPlayer, "fileLovestPath", "count", musics[1].count());
QDomElement netFilePath = writeDomElement(musicPlayer, "netFilePath", "count", musics[2].count());
//extend playlist init here
// for(int i=3; i<fileNamesList.count(); ++i)
// {
// QDomElement extend = m_ddom->createElement("extend" + QString::number(i - 2));
// extend.setAttribute("count",fileNamesList[i].count());
// TTKMusicPlayer.appendChild(extend);
// }
//Class B
foreach(MusicSong song, musics[0])
{
writeDomElementMutilText(fileNormalPath, "value", QStringList() << "name" << "playCount" << "time",
QList<QVariant>() << song.getMusicName() << song.getMusicPlayCount()
<< song.getMusicTime(), song.getMusicPath());
}
void MusicDownloadRecordConfigManager::writeDownloadConfig(const MusicDownloadRecords &records)
{
if(!writeConfig(mappingFilePathFromEnum()))
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot(APPNAME);
QDomElement download = writeDom(musicPlayer, "download");
foreach(const MusicDownloadRecord &record, records)
{
writeDomElementMutilText(download, "value", MusicXmlAttributes() << MusicXmlAttribute("name", record.m_name)
<< MusicXmlAttribute("size", record.m_size)
<< MusicXmlAttribute("time", record.m_time), record.m_path);
}
void DownloadBreakPointConfigManager::writeBreakPointConfig(const DownloadBreakPointItems &records)
{
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement player = createRoot(APPNAME);
QDomElement download = writeDom(player, "breakPoint");
if(!records.isEmpty())
{
writeDomText(download, "url", records.first().m_url);
}
foreach(const DownloadBreakPointItem &record, records)
{
writeDomElementMutil(download, "value", DownloadXmlAttributes() <<
DownloadXmlAttribute("start", record.m_start) <<
DownloadXmlAttribute("end", record.m_end) <<
DownloadXmlAttribute("ready", record.m_ready) );
}
DataFile::DataFile( Type type ) :
QDomDocument( "lmms-project" ),
m_content(),
m_head(),
m_type( type )
{
appendChild( createProcessingInstruction("xml", "version=\"1.0\""));
QDomElement root = createElement( "lmms-project" );
root.setAttribute( "version", LDF_VERSION_STRING );
root.setAttribute( "type", typeName( type ) );
root.setAttribute( "creator", "LMMS" );
root.setAttribute( "creatorversion", LMMS_VERSION );
appendChild( root );
m_head = createElement( "head" );
root.appendChild( m_head );
m_content = createElement( typeName( type ) );
root.appendChild( m_content );
}
void MusicMyDownloadRecordConfigManager::writeDownloadConfig(const MusicDownloadRecord &record)
{
if( !writeConfig( DOWNLOADINFO_FULL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("TTKMusicPlayer");
QDomElement download = writeDom(musicPlayer, "download");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementMutilText(download, "value", QStringList()<<"name"<<"size",
QList<QVariant>()<<record.m_names[i]<<record.m_sizes[i],
record.m_paths[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
void MusicUserConfigManager::writeUserXMLConfig(const MusicUserRecord &record)
{
if( !writeConfig( USERPATH_AL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("QMusicPlayer");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementMutilText(musicPlayer, "username", QStringList()<<"name"<<"userRp"<<"userAl",
QList<QVariant>()<<record.m_names[i]<<record.m_rps[i]<<record.m_als[i],
record.m_pwds[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
void MusicLocalSongSearchRecordObject::writeSearchConfig(const MusicSearchRecord &record)
{
if( !writeConfig( MUSICSEARCH_AL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("QMusicPlayer");
QDomElement download = writeDom(musicPlayer, "searchRecord");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementText(download, "value", "name",
record.m_names[i], record.m_times[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
bool UDXFile::exportRecords(const QString &url, ContactList &list)
{
QDomDocument::clear();
QDomElement root = createElement("DataExchangeInfo");
appendChild(root);
// Original format also was UDX?
bool wasUDX = false;
if (!list.isEmpty())
if (list[0].originalFormat=="UDX")
wasUDX = true;
// XML header
QDomNode node = createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
insertBefore(node, firstChild());
// UDX header
QDomElement recInfo = addElement(root, "RecordInfo");
addElement(recInfo, "VendorInfo", "VendorUDX");
addElement(recInfo, "DeviceInfo", "DeviceUDX");
if (wasUDX)
addElement(recInfo, "UdxVersion", list[0].version);
else
addElement(recInfo, "UdxVersion", "1.0");
addElement(recInfo, "UserAgent", "AgentUDX");
addElement(recInfo, "UserInfo", "UserUDX");
addElement(recInfo, "Encoding", "UTF-8");
addElement(recInfo, "FileSize", " "); // strongly 10 spaces! (~~)
addElement(recInfo, "Date", QDate::currentDate().toString("dd.MM.yyyy"));
addElement(recInfo, "Language","CHS"); // wtf, but this code was in real russian-language udx
QDomElement vcfInfo = addElement(recInfo, "RecordOfvCard");
if (wasUDX)
addElement(vcfInfo, "vCardVersion", list[0].subVersion);
else
addElement(vcfInfo, "vCardVersion", "2.1");
addElement(vcfInfo, "vCardRecord", QString::number(list.count()));
addElement(vcfInfo, "vCardLength", " "); // strongly 10 spaces! (~~)
addElement(recInfo, "RecordOfvCalendar");
addElement(recInfo, "RecordOfSMS");
addElement(recInfo, "RecordOfMMS");
addElement(recInfo, "RecordOfEmail");
// Parent tag for all records
QDomElement vCard = addElement(root, "vCard");
// Add missing sequences to records
int maxSeq = 0;
if (wasUDX) { // wasUDX - simply add missing
foreach (const ContactItem& item, list)
if (item.id.toInt()>maxSeq)
maxSeq = item.id.toInt();
QSet<int> seqs;
for (int i=0; i<list.count(); i++) {
ContactItem& item = list[i];
int currentID = item.id.toInt();
if (currentID<1) // simply missing
item.id = QString::number(++maxSeq);
if (seqs.contains(currentID)) { // duplicate?
_errors << QObject::tr("Warning: contact %1, duplicate id %2 changed to %3")
.arg(item.visibleName).arg(currentID).arg(++maxSeq);
item.id = QString::number(maxSeq);
}
seqs.insert(item.id.toInt());
}
}
else { // if original wasn't UDX, completely renumerate all
for (int i=0; i<list.count(); i++)
bool Xsd::GetEnumXSD( HTTPRequest *pRequest, QString sEnumName )
{
if (sEnumName.isEmpty())
return false;
// ----------------------------------------------------------------------
// sEnumName needs to be in class.enum format
// ----------------------------------------------------------------------
if (sEnumName.count('.') != 1 )
return false;
QStringList lstTypeParts = sEnumName.split( '.' );
// ----------------------------------------------------------------------
// Create Parent object so we can get to its metaObject
// ----------------------------------------------------------------------
QString sParentFQN = "DTC::" + lstTypeParts[0];
int nParentId = QMetaType::type( sParentFQN.toUtf8() );
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
QObject *pParentClass = (QObject *)QMetaType::construct( nParentId );
#else
QObject *pParentClass = (QObject *)QMetaType::create( nParentId );
#endif
const QMetaObject *pMetaObject = pParentClass->metaObject();
QMetaType::destroy( nParentId, pParentClass );
// ----------------------------------------------------------------------
// Now look up enum
// ----------------------------------------------------------------------
int nEnumIdx = pMetaObject->indexOfEnumerator( lstTypeParts[1].toUtf8() );
if (nEnumIdx < 0 )
return false;
QMetaEnum metaEnum = pMetaObject->enumerator( nEnumIdx );
// ----------------------------------------------------------------------
// render xsd for this enum
//
// <xs:simpleType name="RecordingInfo.RecordingDupMethodEnum">
// <xs:restriction base="xs:string">
// <xs:enumeration value="kDupCheckNone">
// <xs:annotation>
// <xs:appinfo>
// <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">1</EnumerationValue>
// </xs:appinfo>
// </xs:annotation>
// </xs:enumeration>
// <xs:enumeration value="kDupCheckSub">
// <xs:annotation>
// <xs:appinfo>
// <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">2</EnumerationValue>
// </xs:appinfo>
// </xs:annotation>
// </xs:enumeration>
// </xs:restriction>
// </xs:simpleType>
//
// <xs:element name="RecordingInfo.RecordingDupMethodEnum" type="tns:RecordingInfo.RecordingDupMethodEnum" nillable="true"/>
// ----------------------------------------------------------------------
if (!pRequest->m_mapParams.contains( "raw" ))
{
appendChild( createProcessingInstruction( "xml-stylesheet",
"type=\"text/xsl\" href=\"/xslt/enum.xslt\"" ));
}
// ----------------------------------------------------------------------
// Create xs:simpleType structure
// ----------------------------------------------------------------------
QDomElement oTypeNode = createElement( "xs:simpleType" );
QDomElement oRestrictNode = createElement( "xs:restriction" );
oTypeNode .setAttribute( "name", sEnumName );
oRestrictNode.setAttribute( "base", "xs:string" );
oTypeNode.appendChild( oRestrictNode );
for( int nIdx = 0; nIdx < metaEnum.keyCount(); nIdx++)
{
QDomElement oEnum = createElement( "xs:enumeration" );
oEnum.setAttribute( "value", metaEnum.key( nIdx ));
// ------------------------------------------------------------------
// Add appInfo to store numerical value & translated text
// ------------------------------------------------------------------
QDomElement oAnn = createElement( "xs:annotation" );
QDomElement oApp = createElement( "xs:appinfo" );
QDomElement oEnumVal = createElement( "EnumerationValue" );
QDomElement oEnumDesc = createElement( "EnumerationDesc" );
oEnum.appendChild( oAnn );
oAnn .appendChild( oApp );
oApp .appendChild( oEnumVal );
oApp .appendChild( oEnumDesc );
oEnumVal .appendChild( createTextNode( QString::number( metaEnum.value( nIdx ))));
oEnumDesc.appendChild( createTextNode( QObject::tr( metaEnum.key( nIdx ), "Enums" )));
oRestrictNode.appendChild( oEnum );
}
// ----------------------------------------------------------------------
QDomElement oElementNode = createElement( "xs:element" );
oElementNode.setAttribute( "name" , sEnumName );
oElementNode.setAttribute( "type" , "tns:" + sEnumName );
oElementNode.setAttribute( "nillable", "true" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
QDomElement oRoot = CreateSchemaRoot();
oRoot.appendChild( oTypeNode );
oRoot.appendChild( oElementNode );
appendChild( oRoot );
// ----------------------------------------------------------------------
// Return xsd doc to caller
// ----------------------------------------------------------------------
QTextStream os( &(pRequest->m_response) );
pRequest->m_eResponseType = ResponseTypeXML;
save( os, 0 );
return true;
}
bool Xsd::GetXSD( HTTPRequest *pRequest, QString sTypeName )
{
bool bIsArray = false;
bool bIsMap = false;
if (sTypeName.isEmpty())
return false;
// ----------------------------------------------------------------------
// Is this a special type name?
// ----------------------------------------------------------------------
if (sTypeName.startsWith( "ArrayOf" ))
{
bIsArray = true;
sTypeName = sTypeName.mid( 7 );
}
if (sTypeName.startsWith( "MapOfString" ))
{
bIsMap = true;
sTypeName = sTypeName.mid( 11 );
}
// ----------------------------------------------------------------------
// Check to see if one of the Qt Types we need to handle special
// ----------------------------------------------------------------------
int id = QMetaType::type( sTypeName.toUtf8() );
// ----------------------------------------------------------------------
// if a DataContract type, we need to prefix name with DTC::
// ----------------------------------------------------------------------
if (id == 0)
{
QString sFQN = "DTC::" + sTypeName;
id = QMetaType::type( sFQN.toUtf8() );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if (!(bIsArray || bIsMap) && ((id == -1) || (id < QMetaType::User)))
return false;
// ------------------------------------------------------------------
// Need to create an instance of the class to access it's metadata.
// ------------------------------------------------------------------
bool bHandled = false;
// --------------------------------------------------------------
// Render XSD
// --------------------------------------------------------------
if (!pRequest->m_mapParams.contains( "raw" ))
{
appendChild( createProcessingInstruction( "xml-stylesheet",
"type=\"text/xsl\" href=\"/xslt/class.xslt\"" ));
}
if (bIsArray)
{
bHandled = RenderArrayXSD( pRequest, sTypeName, id >= QMetaType::User );
}
else if (bIsMap)
{
bHandled = RenderMapXSD( pRequest,
sTypeName,
id >= QMetaType::User );
}
else
{
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
QObject *pClass = (QObject *)QMetaType::construct( id );
#else
QObject *pClass = (QObject *)QMetaType::create( id );
#endif
if (pClass != NULL)
bHandled = RenderXSD( pRequest, pClass );
QMetaType::destroy( id, pClass );
}
return bHandled;
}