TableModelPortExcitation::TableModelPortExcitation(BlocElementBase *bloc , QObject *parent) :
TableModel(bloc,parent)
{
this->bloc = (blocPortExcitation*)bloc;
initHeaders(QStringList() << "Port Actif" << "Port Infinitesimal" << "Type" << "Direction" << "Impédance" << "Type Source" << "Ponderation Amplitude" << "Ponderation Phase" << "Avant Gauche" << "Arrière Droit");
}
void Parse::update(QString doc)
{
if (!isReady()) {
m_updateQueue.append(doc);
return;
}
ensureEndPointHasPrefix("classes");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( isLastRequestSuccessful() ) {
currentObject = json.object();
emit currentObjectChanged(currentObject);
if(!m_updateQueue.isEmpty()) {
update(m_updateQueue.takeFirst());
}
}
else {
// error, drop the queue
m_updateQueue.empty();
}
} );
initHeaders();
request( BaaS::PUT, doc.toUtf8() );
}
PL_treeitem::PL_treeitem(PlaylistItem* _item)
: deep(NULL)
{
// static int countdown= 0;
m_fetchableCount=0;
// qDebug() <<"# of instance" <<countdown++;
// maxdeep = 2;
//intdeep = _vraideep;
m_fetchableIndex = new QList<PlaylistItem*>;
//this->deep = _deep;
//parentItem = parent;
root = false;
if(mapheader == NULL)
{
mapheader = new QList<headerlistview*>;
initHeaders();
}
if(_item!=NULL)
itemData = _item;
else
root = true;
// findChildrendeep();
}
//Objects related
void Parse::create(QString doc)
{
if (!isReady()) {
m_createQueue.append(doc);
return;
}
qWarning()<<"create:"<<doc;
ensureEndPointHasPrefix("classes");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( getHttpCode() == 201 ){
currentObject = json.object();
emit currentObjectChanged(currentObject);
if(!m_createQueue.isEmpty()) {
create(m_createQueue.takeFirst());
}
}
else {
// error, drop the queue
m_createQueue.empty();
}
} );
initHeaders();
request( BaaS::POST, doc.toUtf8() );
}
QNetworkReply* Parse::uploadFileData(QByteArray data, QString name)
{
if (!isReady() || data.isEmpty()) return NULL;
if (name.isEmpty()) {
// compute name from content
}
setEndPoint( "files/"+name);
QMimeDatabase db;
QMimeType mime = db.mimeTypeForData(data);
initHeaders();
setHeader(QNetworkRequest::ContentTypeHeader, mime.name().toUtf8());
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( getHttpCode() == 201 ){
currentObject = json.object();
// Create fileLit object
QString mainObj = "{\"url\": \""+currentObject.value("url").toString()+
"\",\"file\": {\"name\": \""+currentObject.value("name").toString()+
",\"__type\": \"File\"}}";
setEndPoint("classes/FilesList");
create( mainObj);
emit fileUploaded( currentObject);
}
} );
return request( BaaS::POST, data );
}
void Parse::updatePML(QString doc)
{
if (!isReady()) {
m_updateQueue.append(doc);
return;
}
ensureEndPointHasPrefix("classes");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( isLastRequestSuccessful() ) {
qWarning()<<"updatePML Result:"<<json.object();
currentObject = json.object();
emit currentObjectChanged(currentObject);
emit pmlUploaded();
if(!m_updateQueue.isEmpty()) {
update(m_updateQueue.takeFirst());
}
else {
QMetaObject::invokeMethod(object, "hideWorkingScreen");
pmlList();
}
}
else {
// error, drop the queue
m_updateQueue.empty();
}
} );
initHeaders();
request( BaaS::PUT, doc.toUtf8() );
}
void Parse::signup( QString username, QString password, QString email )
{
if (!isReady()) return;
setEndPoint("users");
QJsonObject obj{
{"username", username},
{"password", password},
{"email", email}
};
setMasterKey("Remy");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( getHttpCode() == 201 ){
QJsonObject obj = json.object();
sessionId = obj.value("sessionToken").toString();
userId = obj.value("objectId").toString();
userName = obj.value("username").toString();
qDebug() << "objectId" << obj.value("objectId").toString();
qDebug() << "sessionToken" << sessionId;
qDebug() << "res" << obj;
emit loginChanged();
}
} );
initHeaders();
request( BaaS::POST, QJsonDocument(obj).toJson());
setMasterKey("");
}
gpTraceSummaryTable::gpTraceSummaryTable(gpTraceDataContainer* pDataContainer, gpTraceView* pSessionView, eCallType callType)
: acListCtrl(nullptr), m_callType(callType), m_pSessionDataContainer(pDataContainer), m_pTraceView(pSessionView), m_lastSelectedRowIndex(-1)
{
QStringList columnCaptions;
columnCaptions << GP_STR_SummaryTableColumnCall;
columnCaptions << GP_STR_SummaryTableColumnMaxTime;
columnCaptions << GP_STR_SummaryTableColumnMinTime;
columnCaptions << GP_STR_SummaryTableColumnAvgTime;
columnCaptions << GP_STR_SummaryTableColumnCumulativeTime;
columnCaptions << GP_STR_SummaryTableColumnPercentageOfTotalTime;
columnCaptions << GP_STR_SummaryTableColumnNumberOfCalls;
initHeaders(columnCaptions, false);
setShowGrid(true);
m_logic.Init(m_callType, m_pSessionDataContainer, pSessionView);
// fill Table widget
FillTable();
setSortingEnabled(true);
setSelectionMode(QAbstractItemView::SingleSelection);
setContextMenuPolicy(Qt::NoContextMenu);
// Connect to the cell entered signal
setMouseTracking(true);
bool rc = connect(this, SIGNAL(cellEntered(int, int)), this, SLOT(OnCellEntered(int, int)));
GT_ASSERT(rc);
}
void Parse::deleteObject(QString doc)
{
if (!isReady()) {
m_deleteQueue.append(doc);
return;
}
ensureEndPointHasPrefix("classes");
//Get objectId to be deleted
QString deletedObjectId = getEndPoint();
int found = deletedObjectId.lastIndexOf('/');
int length = deletedObjectId.length();
deletedObjectId = deletedObjectId.right( length - found -1);
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
Q_UNUSED(json);
disconnect(m_conn);
if ( isLastRequestSuccessful() ) {
emit objectDeleted( deletedObjectId );
if(!m_deleteQueue.isEmpty()) {
deleteObject(m_deleteQueue.takeFirst());
}
}
else {
// error, drop the queue
m_deleteQueue.empty();
}
} );
initHeaders();
request( BaaS::DELETE, doc.toUtf8() );
}
QNetworkReply* Parse::uploadFile(QUrl url, QString name)
{
QString filePath = url.toLocalFile();
if (!isReady() || !QFile::exists(filePath)) return NULL;
if (name.isEmpty()) name = url.fileName();
setEndPoint( "files/"+name);
QMimeDatabase db;
QMimeType mime = db.mimeTypeForFile(filePath);
QFile file(filePath);
if (mime.inherits("text/plain")){
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return NULL;
}
else{
if (!file.open(QIODevice::ReadOnly ))
return NULL;
}
initHeaders();
setHeader(QNetworkRequest::ContentTypeHeader, mime.name().toUtf8());
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( getHttpCode() == 201 ){
currentObject = json.object();
emit fileUploaded( currentObject);
}
} );
return request( BaaS::POST, file.readAll() );
}
AtMegaWebServer::AtMegaWebServer(PathHandler handlers[],
const char** headers)
: handlers_(handlers),
server_(EthernetServer(80)),
path_(NULL),
request_type_(UNKNOWN_REQUEST),
client_(EthernetClient(255))
{
if (headers) initHeaders(headers);
}
void Parse::deleteUser( QString objectId)
{
if (!isReady() || sessionId.isEmpty()) return;
setEndPoint("users/" + objectId );
initHeaders();
setRawHeader("X-Parse-Session-Token", sessionId.toUtf8());
request( BaaS::DELETE);
}
Game::Game(void)
{
wallmanager = new Wallmanager();
dot = new Dot();
powerup = new Powerup();
pacman = new Pacman();
ambusher = new Ambusher();
chaser = new Chaser();
fickle = new Fickle();
stupid = new Stupid();
speed = 200;
level = 1;
score = 0;
paused = false;
initHeaders();
newLevel();
}
QNetworkReply* Parse::deleteFile(QString fileName)
{
if (!isReady() || getMasterKey().isEmpty()) return NULL;
setEndPoint( "files/" + fileName);
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
Q_UNUSED(json);
disconnect(m_conn);
if ( isLastRequestSuccessful() ) {
emit objectDeleted( fileName );
}
} );
initHeaders();
setRawHeader("X-Parse-Master-Key", getMasterKey().toUtf8());
return request( BaaS::DELETE );
}
void Parse::passwordReset( QString email)
{
if (!isReady()) return;
setEndPoint("requestPasswordReset");
QJsonObject obj{
{"email", email}
};
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
Q_UNUSED(json);
if ( isLastRequestSuccessful() ) {
}
} );
initHeaders();
request( BaaS::POST, QJsonDocument(obj).toJson() );
}
QNetworkReply* Parse::get( QString include)
{
Q_UNUSED(include); //TODO implement include
if (!isReady()) return NULL;
ensureEndPointHasPrefix("classes");
initHeaders();
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( isLastRequestSuccessful() ) {
QJsonObject obj = json.object();
currentObject = obj;
postProcessGet(obj);
}
} );
return request( BaaS::GET);
}
void Parse::logout( )
{
if (!isReady()) return;
setEndPoint("logout");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
Q_UNUSED(json);
if ( isLastRequestSuccessful() ) {
sessionId = "";
userId = "";
userName = "";
removeRawHeader("X-Parse-Session-Token");
emit loginChanged();
}
} );
initHeaders();
request( BaaS::POST);
}
void Parse::login( QString username, QString password )
{
setHostURI(Cloud::getValueFor("serverURL",""));
if (!isReady()) return;
QUrlQuery postData;
postData.addQueryItem("username", username);
postData.addQueryItem("password", password);
setEndPoint( "login?" + postData.toString() ); //TODO improve me : not use endpoint to give url encoded params
initHeaders();
if (registerInstallationOnLogin)
setRawHeader("X-Parse-Installation-Id", "1");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( isLastRequestSuccessful() ) { //getHttpCode() == 201 ){
QJsonObject obj = json.object();
sessionId = obj.value("sessionToken").toString();
userId = obj.value("objectId").toString();
userName = obj.value("username").toString();
// qWarning()<<obj;
qWarning() << "objectId" << obj.value("objectId").toString();
qWarning() << "sessionToken" << sessionId;
setRawHeader("X-Parse-Session-Token", sessionId.toUtf8());
emit loginChanged();
}
} );
request( BaaS::GET);
}
void Parse::postPML( QString type, QString title, QString description, QByteArray pml_file, QString keywords )
{
qWarning()<<"postPML, ready:"<<isReady();
while (!isReady()) { }
setEndPoint("classes/Pml");
QJsonObject obj;
QJsonObject owner{
{"__type","Pointer"},
{"className","_User"},
{"objectId",userId}
};
obj.insert("owner",owner);
obj.insert("type",type);
QByteArray zipdata;
if (type=="pml") {
QBuffer buf(&zipdata);
QuaZip zip(&buf);
zip.open(QuaZip::mdCreate);
QuaZipFile file(&zip);
file.open(QIODevice::WriteOnly, QuaZipNewInfo("session.pml"));
file.write(pml_file);
file.close();
zip.close();
}
if (type=="psk") {
zipdata = pml_file;
QBuffer buf(&zipdata);
QuaZip zip(&buf);
zip.open(QuaZip::mdUnzip);
// check Package.json exist
if (!zip.setCurrentFile("package.json")) {
// ERROR
qWarning()<<"ERROR - package.json missing";
ask(mainwindow,"Invalid skin package.\n'package.json' file missing",1);
return;
}
// open Package.json
QuaZipFile file(&zip);
file.open(QIODevice::ReadOnly);
QByteArray _ba = file.readAll();
QJsonDocument json = QJsonDocument::fromJson(_ba);
if (json.object().value("model").isUndefined()) {
// ERROR
qWarning()<<"ERROR model empty";
ask(mainwindow,"Invalid skin package.\nModel not defined in package.json file",1);
return;
}
QString _model = json.object().value("model").toString();
QString _title = json.object().value("title").toString();
QString _description = json.object().value("description").toString();
QString _author = json.object().value("author").toString();
QString _email = json.object().value("email").toString();
QString _url = json.object().value("url").toString();
title = _title;
description = _description + "\r\n" +
"Author : "+_author + "\r\n" +
"Email : "+_email + "\r\n" +
"Url : "+_url;
// "Email :<a href=\"mailto://"+_email +"\">"+_email+"</a>\r\n" +
// "Url :<a href=\""+_url +"\">"+_url+"</a>";
file.close();
}
obj.insert("data",QString(zipdata.toBase64()));
QJsonObject acl{
{ userId, QJsonObject{
{"read", true},
{"write", true}
}
}
};
obj.insert("ACL",acl);
obj.insert("title",title);
obj.insert("description",description);
obj.insert("keywords",keywords);
// parse pml to generate objetcs list
// This should be moved to parse.Cloud
// DONE
// QDomDocument document;
// document.setContent( pml_file );
// QDomElement documentElement = document.documentElement();
// QDomNodeList elements = documentElement.elementsByTagName( "object" );
// QString keywords = "|";
// for (int i=0; i<elements.size();i++ )
// {
// QDomElement object = elements.at(i).toElement();
// QString name = object.attribute("name");
// keywords.append( name + QString("|") );
// qWarning()<<keywords;
// }
// obj.insert("keywords",keywords);
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
// qWarning()<<"disconnect"<<m_conn;
disconnect(m_conn);
if ( getHttpCode() == 201 ){
qWarning()<<"postPML Result:"<<json.object();
emit pmlUploaded();
}
} );
qWarning()<<"connect"<<m_conn;
initHeaders();
request( BaaS::POST, QJsonDocument(obj).toJson());
}
QNetworkReply *Parse::query(QString endPoint, QUrlQuery extraParams)
{
if (!isReady()) return NULL;
if (extraParams.isEmpty())
setEndPoint(endPoint);
else setEndPoint( endPoint + "?" + extraParams.toString() ); //TODO improve me : not use endpoint to give url encoded params
ensureEndPointHasPrefix("classes");
m_conn = connect(this, &BaaS::replyFinished, [=](QJsonDocument json, QNetworkReply *reply){
disconnect(m_conn);
if (isLastRequestSuccessful()){
//structure to return from parse
QHash<int, QByteArray> roles = QHash<int, QByteArray>();
QVector<QVariantMap> data = QVector<QVariantMap>();
Q_ASSERT(json.isObject());
QJsonObject obj = json.object();
QJsonValue tmp = obj.value("results");
if (tmp.isArray()){
QJsonArray res = tmp.toArray();
for ( QJsonValue elem: res){
if (elem.isObject()){
obj = elem.toObject();
//Update roles
QStringList keys = obj.keys();
for (QString roleName : keys )
{
if ( roles.key( roleName.toUtf8(), -1) == -1)
roles[roles.size()] = roleName.toUtf8();
}
//Add values
data.push_back( obj.toVariantMap());
}
}
emit querySucceeded(roles, data, reply);
}
//else if (tmp.isObject()){
//obj = tmp.toObject();//Update roles
else {
QStringList keys = obj.keys();
for (QString roleName : keys )
{
if ( roles.key( roleName.toUtf8(), -1) == -1)
roles[roles.size()] = roleName.toUtf8();
}
//Add values
data.push_back( obj.toVariantMap());
emit querySucceeded(roles, data, reply);
}
}
} );
initHeaders();
return request( BaaS::GET);
}
/******************************************************************************
* Send the email message specified in an event.
* Reply = 1 if the message was sent - 'errmsgs' may contain copy error messages.
* = 0 if the message is queued for sending.
* = -1 if the message was not sent - 'errmsgs' contains the error messages.
*/
int KAMail::send(JobData& jobdata, QStringList& errmsgs)
{
QString err;
KPIMIdentities::Identity identity;
if (!jobdata.event.emailFromId())
jobdata.from = Preferences::emailAddress();
else
{
identity = Identities::identityManager()->identityForUoid(jobdata.event.emailFromId());
if (identity.isNull())
{
kError() << "Identity" << jobdata.event.emailFromId() << "not found";
errmsgs = errors(i18nc("@info", "Invalid 'From' email address.<nl/>Email identity <resource>%1</resource> not found", jobdata.event.emailFromId()));
return -1;
}
if (identity.emailAddr().isEmpty())
{
kError() << "Identity" << identity.identityName() << "uoid" << identity.uoid() << ": no email address";
errmsgs = errors(i18nc("@info", "Invalid 'From' email address.<nl/>Email identity <resource>%1</resource> has no email address", identity.identityName()));
return -1;
}
jobdata.from = identity.fullEmailAddr();
}
if (jobdata.from.isEmpty())
{
switch (Preferences::emailFrom())
{
#ifdef KMAIL_SUPPORTED
case Preferences::MAIL_FROM_KMAIL:
errmsgs = errors(i18nc("@info", "<para>No 'From' email address is configured (no default email identity found)</para>"
"<para>Please set it in <application>KMail</application> or in the <application>KAlarm</application> Configuration dialog.</para>"));
break;
#endif
case Preferences::MAIL_FROM_SYS_SETTINGS:
errmsgs = errors(i18nc("@info", "<para>No 'From' email address is configured.</para>"
"<para>Please set it in the KDE System Settings or in the <application>KAlarm</application> Configuration dialog.</para>"));
break;
case Preferences::MAIL_FROM_ADDR:
default:
errmsgs = errors(i18nc("@info", "<para>No 'From' email address is configured.</para>"
"<para>Please set it in the <application>KAlarm</application> Configuration dialog.</para>"));
break;
}
return -1;
}
jobdata.bcc = (jobdata.event.emailBcc() ? Preferences::emailBccAddress() : QString());
kDebug() << "To:" << jobdata.event.emailAddresses(",")
<< endl << "Subject:" << jobdata.event.emailSubject();
MailTransport::TransportManager* manager = MailTransport::TransportManager::self();
MailTransport::Transport* transport = 0;
if (Preferences::emailClient() == Preferences::sendmail)
{
kDebug() << "Sending via sendmail";
const QList<MailTransport::Transport*> transports = manager->transports();
for (int i = 0, count = transports.count(); i < count; ++i)
{
if (transports[i]->type() == MailTransport::Transport::EnumType::Sendmail)
{
// Use the first sendmail transport found
transport = transports[i];
break;
}
}
if (!transport)
{
QString command = KStandardDirs::findExe(QLatin1String("sendmail"),
QLatin1String("/sbin:/usr/sbin:/usr/lib"));
transport = manager->createTransport();
transport->setName(QLatin1String("sendmail"));
transport->setType(MailTransport::Transport::EnumType::Sendmail);
transport->setHost(command);
transport->setRequiresAuthentication(false);
transport->setStorePassword(false);
manager->addTransport(transport);
transport->writeConfig();
kDebug() << "Creating sendmail transport, id=" << transport->id();
}
}
else
{
kDebug() << "Sending via KDE";
transport = manager->transportByName(identity.transport(), true);
if (!transport)
{
kError() << "No mail transport found for identity" << identity.identityName() << "uoid" << identity.uoid();
errmsgs = errors(i18nc("@info", "No mail transport configured for email identity <resource>%1</resource>", identity.identityName()));
return -1;
}
}
kDebug() << "Using transport" << transport->name() << ", id=" << transport->id();
MailTransport::TransportJob* mailjob = manager->createTransportJob(transport->id());
if (!mailjob)
{
kError() << "Failed to create mail transport job for identity" << identity.identityName() << "uoid" << identity.uoid();
errmsgs = errors(i18nc("@info", "Unable to create mail transport job"));
return -1;
}
KMime::Message message;
initHeaders(message, jobdata);
err = appendBodyAttachments(message, jobdata);
if (!err.isNull())
{
kError() << "Error compiling message:" << err;
errmsgs = errors(err);
return -1;
}
mailjob->setSender(KPIMUtils::extractEmailAddress(jobdata.from));
mailjob->setTo(jobdata.event.emailPureAddresses());
if (!jobdata.bcc.isEmpty())
mailjob->setBcc(QStringList(KPIMUtils::extractEmailAddress(jobdata.bcc)));
mailjob->setData(message.encodedContent());
mJobs.enqueue(mailjob);
mJobData.enqueue(jobdata);
if (mJobs.count() == 1)
{
// There are no jobs already active or queued, so send now
connect(mailjob, SIGNAL(result(KJob*)), instance(), SLOT(slotEmailSent(KJob*)));
mailjob->start();
}
return 0;
}
