def post(self, team_id):
current_user = get_jwt_identity()
data = task_parser.parse_args()
if TaskModel.find_by_title(data['title']):
return {
'message': 'Task {} already exists'.format(data['title'])
}, 409
user = UserModel.query.get(current_user)
new_task = TaskModel(data['title'], data['status'], data["priority"])
new_task.reporter_id = user.id
if data['description']:
new_task.description = data['description']
if data['assigne_id']:
new_task.assigne_id = data['assigne_id']
if data['planneddate']:
new_task.planneddate = data['planneddate']
new_task.team_id = team_id
try:
new_task.save_to_db()
resp = jsonify({
'message':
'Task {} was created'.format(data['title']),
'id':
new_task.id
})
resp.status_code = 200
return resp
except:
return {'message': 'Something went wrong'}, 500
def test_can_retrieve_all_tasks(self):
task_recurring = TaskModel({
'function': 'time.time',
'schedule': '1 * * * *'
})
task_once = TaskModel({'function': 'time.time', 'schedule': 'now'})
db.session.add(task_recurring)
db.session.add(task_once)
db.session.commit()
res = self.app.get('/api/v1.0/schedule')
j = json.loads(res.data)
assert len(j) == 2
def edit(id):
title = request.form['title']
description = request.form['description']
startdate = request.form['startdate']
enddate = request.form['enddate']
status = request.form['status']
TaskModel.updateById(id=id,
newtitle=title,
newdescription=description,
newstartdate=startdate,
newenddate=enddate,
newstatus=status)
return redirect(url_for('hello_world'))
def post(cls):
claims = get_jwt_claims()
company_id = claims.get("company_id")
tasks_json = request.get_json()["tasks"]
print(tasks_json)
tasks = task_schema.load(tasks_json, many=True)
for task in tasks:
task.company_id = company_id
TaskModel.save_massive_to_db(tasks)
return {"message": "Tasks added suscessfully"}
def test_can_remove_task_by_id(self):
task = TaskModel({'function': 'time.time', 'schedule': '1 * * * *'})
db.session.add(task)
db.session.commit()
res = self.app.delete('/api/v1.0/schedule', json={'id': task.id})
assert res.status_code == 204
def put(cls, id):
task_json = request.get_json()["task"]
task = TaskModel.find_by_id(id)
if task:
task.customer_id = task_json["customer_id"]
task.planogram_id = task_json["planogram_id"]
task.start_before = task_json["start_before"]
task.complete_before = task_json["complete_before"]
task.agent_id = task_json.get("agent_id")
task.save_to_db()
return {
"message": "task updated",
"task": {
**task_schema.dump(task), "customer": task.customer.name,
"planogram": task.planogram.name,
"agent": task.agent.first_name if task.agent else None,
"agentData": agent_schema.dump(task.agent)
}
}
return {"message": "not found"}, 404
def get(cls, id):
task = TaskModel.find_by_id(id)
if task:
return task_schema.dump(task)
return {"message": "not found"}, 404
def __init__(self, *args):
super().__init__(*args)
from shared.config import SettingsAccessorBase
from Settings import DEFAULT_SETTINGS
self.settings = SettingsAccessorBase(constants.FRONTEND_CONFIG_FILE,
DEFAULT_SETTINGS)
self.aboutToQuit.connect(lambda: self.settings.save())
from models import TaskModel, AdapterManager, ProxyModel
from Schedule.model import SchedulerModel
self.taskModel = TaskModel()
self.proxyModel = ProxyModel()
self.proxyModel.setSourceModel(self.taskModel)
self.schedulerModel = SchedulerModel(self)
self.schedulerModel.setSourceModel(self.taskModel)
self.adapterManager = AdapterManager(taskModel=self.taskModel)
for name, item in self.settings.itr_sections_with_prefix("adapter"):
self.adapterManager.loadAdapter(item)
from Tasks.action import TaskCreationAgent
self.taskCreationAgent = TaskCreationAgent(self)
self.taskCreationAgent.available.connect(self.slotCreateTask)
self.taskCreationDlg = None
from Services import SessionService
self.sessionService = SessionService(self)
from Widgets.Main import QmlMain
self.qmlWin = QmlMain(None)
self.qmlWin.show()
self.aboutToQuit.connect(lambda: self.qmlWin.deleteLater())
class TaskService:
def __init__(self):
self.model = TaskModel()
def add(self, params):
return self.model.add(params)
def update(self, item_id, params):
return self.model.update(item_id, params)
def delete(self, item_id):
return self.model.delete(item_id)
def list(self):
response = self.model.list_items()
return response
def put(self, task_id):
task = TaskModel.query.get(task_id)
args = task_put_parser.parse_args()
if args['title']:
if TaskModel.find_by_title(args['title']):
return {
'message':
'Task with Name {} already exists'.format(args['name'])
}, 409
task.title = args['title']
if args['description']:
task.description = args['description']
if args['status']:
task.status = args['status']
if args['priority']:
task.priority = args['priority']
if args['assigne_id']:
task.assigne_id = args['assigne_id']
if args['reporter_id']:
task.reporter_id = args['reporter_id']
if args['planneddate']:
task.planneddate = args['planneddate']
try:
task.update_db()
return {'message': 'User Details Updated'}, 200
except:
return {'message': 'Something went wrong'}, 500
def get(self, SK8RAT_name):
# Check SK8RAT by name
SK8RAT = SK8RATModel.query.filter(
SK8RATModel.name == SK8RAT_name).first()
# If name doesn't exist, error; else grab guid
if (not SK8RAT):
return {'message': 'SK8RAT does not exist.'}
guid = SK8RAT.guid
return TaskModel.return_single(guid)
def post(self, task_id):
args = task_post_args.parse_args()
result = TaskModel.query.filter_by(id=task_id).first()
if result:
abort(409, message="Task id taken")
task = TaskModel(id=task_id, title=args['title'], desc=args['desc'])
db.session.add(task)
db.session.commit()
return task, 201
def clean_up_campaigns(request):
status = 200
task = TaskModel.all().get()
if task:
task_key = task.key()
logging.info('Executing clean up campaign task: %s' % task_key)
if (task.execute()):
logging.info('Finished clean up campaign task: %s' % task_key)
stats = 201
return HttpResponse(status = status)
def newTask():
if request.method == "POST":
title = request.form['title']
description = request.form['description']
startdate = request.form['startdate']
enddate = request.form['enddate']
status = request.form['status']
# try:
newtask = TaskModel(title=title,
description=description,
startdate=startdate,
enddate=enddate,
status=status)
newtask.insert()
return redirect(url_for('hello_world'))
# # except:
# flash("Failed to insert,database connection error")
# print("failed")
# return redirect(url_for('hello_world'))
return render_template('index.html')
def delete(cls):
ids = request.get_json()["ids"]
task = TaskModel.find_by_agents(ids)
if task:
return {"message":"There are task with these agents"}, 400
agents = AgentModel.get_many(ids)
AgentModel.delete_many(ids)
return {"message":"Agents deleted!"}
def get(cls):
claims = get_jwt_claims()
company_id = claims.get("company_id")
tasks = TaskModel.get_tasks(company_id)
return [{
**task_schema.dump(task), "customer": task.customer.name,
"planogram": task.planogram.name,
"agent": task.agent.first_name if task.agent else None,
"agentData": agent_schema.dump(task.agent)
} for task in tasks]
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('function',
type=str,
required=True,
location='json')
parser.add_argument('schedule',
type=str,
required=True,
location='json')
parser.add_argument('args', type=list, location='json')
schedule = parser.parse_args()
task = TaskModel(schedule)
uuid = ''
if 'now' == schedule['schedule']:
uuid = cel.send_task('worker.dynamicTask',
kwargs={
'taskname': schedule.function,
'taskargs': schedule.args
})
elif schedule['schedule'].isdigit():
time_now = time.time()
time_gap = (int(schedule.schedule) - time_now) / 1000
uuid = cel.send_task('worker.dynamicTask',
kwargs={
'taskname': schedule.function,
'taskargs': schedule.args
},
countdown=time_gap)
task.uuid = str(uuid)
db.session.add(task)
db.session.commit()
if task.id:
return task, 201
def per_ip(ip, op_id):
try:
cur_pass = Password.objects.get(p_ip=ip).p_password
except:
cur_pass = "******"
result = invoke_shell_remote.delay(
shell_path="/cygdrive/d/wintool/WinTool.exe -Patch:down && /cygdrive/d/wintool/WinTool.exe -Patch:ins",
ip=ip,
password=cur_pass
)
if not result.result:
m_result = ""
else:
m_result = result.result
m_task = TaskModel(
t_operation=op_id,
t_content=ip,
t_task_id=result.id,
t_status=result.status,
t_result=m_result
)
m_task.save()
def execute(task, campaign):
storage_query = Storage.all().filter('campaign =', campaign)
if (storage_query.count(limit = 1)):
for datum in storage_query.fetch(100):
logging.info('checking for stats: %s' % datum.stats.key())
if (Histogram.has(datum.stats) and not TaskModel.has(datum.stats)): #perhaps use a pickled dictionary instead of count queries
if (not TaskModel(object = datum.stats, task = 'delete histogram').put()):
logging.critical('Could not create delete histogram task for %s' % datum.stats)
else:
datum.stat.delete()
datum.delete()
else:
task.delete()
logging.info('Nothing left in storage to clean up for campaign %s' % campaign)
return True
def delete(cls, id):
task = TaskModel.find_by_planogram(id)
if task:
return {"message": "There are task with this planogram"}, 400
planogram = PlanogramModel.find_by_id(id)
if planogram:
planogram.delete_from_db()
return {"message": "Planogram deleted!"}
return {"message": "not found"}, 404
def mutate(root, info, item, task_id, index):
list_id = 1
completed = False
task = Task(task_id=task_id,
item=item,
completed=completed,
index=index)
data = [
TaskModel(
task_id=task_id,
list_id=list_id,
item=item,
completed=False,
index=index,
)
]
session.bulk_save_objects(data)
session.commit()
return CreateTask(task=task)
def __init__(self, *args):
super().__init__(*args)
from models import TaskModel, AdapterManager, ProxyModel
from libxware import XwareAdapterThread
self.taskModel = TaskModel()
self.proxyModel = ProxyModel()
self.proxyModel.setSourceModel(self.taskModel)
self.adapterManager = AdapterManager()
self.xwareAdapterThread = XwareAdapterThread({
"host": "127.0.0.1",
"port": 9000,
})
self.xwareAdapterThread.start()
self.qmlWin = QmlMain(None)
self.qmlWin.show()
def test_update_endpoint_timestamp_was_changed_after_task_removed(self):
task = TaskModel({'function': 'time.time', 'schedule': '1 * * * *'})
db.session.add(task)
db.session.commit()
res = self.app.get('/api/v1.0/last_update')
j = json.loads(res.data)
old_date = j['date']
# waiting before deleting task
time.sleep(1)
# weird but we need to reconcile object for some reasons
task = db.session.merge(task)
self.app.delete('/api/v1.0/schedule', json={'id': task.id})
res = self.app.get('/api/v1.0/last_update')
j = json.loads(res.data)
assert j['date'] > old_date
def post(self, SK8RAT_name):
# Get raw request and read as json blob
request_raw = request.data.decode("UTF-8")
json_blob = json.loads(request_raw)
# Check SK8RAT by name
SK8RAT = SK8RATModel.query.filter(
SK8RATModel.name == SK8RAT_name).first()
# If name doesn't exist, error; else grab guid
if (not SK8RAT):
return {'message': 'SK8RAT does not exist.'}
guid = SK8RAT.guid
# Check guid against tasking database
task = TaskModel.query.filter(TaskModel.guid == guid).first()
if (task is None):
# task was not found, create initial
new_task = TaskModel(guid=guid,
task_id=1,
task=json_blob['task'],
task_status="wait",
task_output="")
else:
# task was found, find most recent task_id for this guid, add 1
task2 = TaskModel.query.filter(TaskModel.guid == guid).order_by(
TaskModel.task_id.desc()).first()
new_task = TaskModel(guid=guid,
task_id=task2.task_id + 1,
task=json_blob['task'],
task_status="wait",
task_output="")
new_task.save_to_db()
message = "Task " + json_blob['task'] + " with task id " + str(new_task.task_id) +\
" assigned to " + SK8RAT.name + "."
return {'message': message}
def delete(self):
return TaskModel.delete_all()
from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, \
QTableWidgetItem, QMessageBox, QDialog
from views import Ui_SolveViewer, Ui_TaskViewer, Ui_NewTaskDialog, \
Ui_NewConstraintDialog, Ui_ExportDialog, Ui_AboutDialog
import sys
from models import TaskModel, TagModel, TaskTagModel, CONNECTION
from utility import Solver, NoSolutionError, SolverException, save_csv, compress
from PyQt5.QtGui import QColor, QPixmap
import csv
import numpy as np
from pyqtgraph import PlotDataItem
from PyQt5.QtCore import Qt
TASKS = TaskModel()
TAGS = TagModel()
TASKS_TAGS = TaskTagModel()
class AboutDialog(QDialog, Ui_AboutDialog):
def __init__(self, parent):
super().__init__(parent)
self.setupUi(self)
self.imageLabel.setPixmap(
QPixmap('default_image.jpg').scaledToWidth(300))
class SolutionViewer(QMainWindow, Ui_SolveViewer):
def __init__(self):
super().__init__()
self.setupUi(self)
self.coefs = []
def __init__(self, *args):
super().__init__(*args)
logging.info("XWARE DESKTOP STARTS")
self.setApplicationName("XwareDesktop")
self.setApplicationVersion(__version__)
os.chdir(os.path.dirname(os.path.abspath(__file__)))
self.checkOneInstance()
font = QFont()
font.setPointSize(10)
self.setFont(font)
QIcon.setThemeName(
"") # Compat for Ubuntu 14.04: A magical fix for #102
from Settings import DEFAULT_SETTINGS
from shared.config import SettingsAccessorBase
self.settings = SettingsAccessorBase(constants.FRONTEND_CONFIG_FILE,
DEFAULT_SETTINGS)
self.aboutToQuit.connect(lambda: self.settings.save())
from models import TaskModel, AdapterManager, ProxyModel
self.taskModel = TaskModel()
self.proxyModel = ProxyModel()
self.proxyModel.setSourceModel(self.taskModel)
self.adapterManager = AdapterManager(taskModel=self.taskModel)
for name, item in self.settings.itr_sections_with_prefix("adapter"):
self.adapterManager.loadAdapter(item)
# components
from Services import SessionService
self.sessionService = SessionService(self)
from Widgets.systray import Systray
from Notify import Notifier
from Schedule.model import SchedulerModel
from Tasks.action import TaskCreationAgent
self.systray = Systray(self)
self.notifier = Notifier(taskModel=self.taskModel,
frontendSettings=self.settings["frontend"],
parent=self)
self.schedulerModel = SchedulerModel(self)
self.schedulerModel.setSourceModel(self.taskModel)
self.taskCreationAgent = TaskCreationAgent(self)
self.monitorWin = None
self.applySettings.connect(self.slotCreateCloseMonitorWindow)
# Legacy parts
from legacy import main
from legacy.frontendpy import FrontendPy
self.mainWin = main.MainWindow(
adapter=self.adapterManager[0],
taskCreationAgent=self.taskCreationAgent,
frontendSettings=self.settings["frontend"],
app=self)
self.mainWin.show()
self.frontendpy = FrontendPy(
taskCreationAgent=self.taskCreationAgent,
legacySettings=self.settings["legacy"],
adapterSettings=self.settings["adapter-legacy"],
adapter=self.adapterManager[0],
mainWin=self.mainWin,
parent=self)
self.sigMainWinLoaded.emit()
self.applySettings.emit()
upgradeGuide = None
if self.settings.myGet("internal", "previousversion") == "0.8":
# upgraded or fresh installed
upgradeGuide = "https://github.com/Xinkai/XwareDesktop/wiki/使用说明"
else:
previousdate = self.settings.getfloat("internal", "previousdate")
if previousdate == 0: # upgrade from pre-0.12
upgradeGuide = "https://github.com/Xinkai/XwareDesktop/wiki/升级到0.12"
if upgradeGuide:
from PyQt5.QtCore import QUrl
from PyQt5.QtGui import QDesktopServices
QDesktopServices.openUrl(QUrl(upgradeGuide))
self.settings.set("internal", "previousversion", __version__)
self.settings.setfloat("internal", "previousdate", DATE)
def __init__(self):
self.model = TaskModel()
def delete(cls):
ids = request.get_json()["ids"]
TaskModel.delete_many(ids)
return {"message": "Tasks deleted!"}
def get(self):
return TaskModel.return_all()
def hello_world():
records = TaskModel.read_all()
return render_template('index.html', records=records)
