def post(self, request, *args, **kwargs):
payment_id = request.POST.get('_submit')
if payment_id:
now = datetime.datetime.now()
payment = Payment.objects.filter(payment_id=payment_id)[0]
if not payment.is_applied:
payment.create_time = now
payment.is_applied = True
payment.save(update_fields=['create_time', 'is_applied'])
route = Route.objects.filter(route_name=PAYMENT_APPLY,
company=self.user.company)[0]
document = Document.objects.get_or_create(document_id=payment_id,
defaults={
'document_type':
PAYMENT_TYPE,
'user': self.user,
'create_date': now
})
item = Item.objects.get_or_create(document=document[0],
item_name=PAYMENT_APPLY,
route=route,
user=self.user)
#重新发起申请
if item[0].status == ITEM_REJECTED:
workflow = Workflow()
workflow.reApplyWorkflow(item[0], self.user, '')
else: #新申请
workflow = Workflow()
workflow.applyWorkflow(route, item[0], self.user)
self.message_user(u"提交申请成功", 'success')
return super(PaymentAdmin, self).post(request, *args, **kwargs)
def test_magic_args(self):
"""Magic args"""
# cache original sys.argv
oargs = sys.argv[:]
# delsettings
sys.argv = [oargs[0]] + [b'workflow:delsettings']
try:
wf = Workflow(default_settings={'arg1': 'value1'})
self.assertEqual(wf.settings['arg1'], 'value1')
self.assertTrue(os.path.exists(wf.settings_path))
self.assertRaises(SystemExit, lambda wf: wf.args, wf)
self.assertFalse(os.path.exists(wf.settings_path))
finally:
sys.argv = oargs[:]
# delcache
sys.argv = [oargs[0]] + [b'workflow:delcache']
def somedata():
return {'arg1': 'value1'}
try:
wf = Workflow()
cachepath = wf.cachefile('somedir')
os.makedirs(cachepath)
wf.cached_data('test', somedata)
self.assertTrue(os.path.exists(wf.cachefile('test.cpickle')))
self.assertRaises(SystemExit, lambda wf: wf.args, wf)
self.assertFalse(os.path.exists(wf.cachefile('test.cpickle')))
finally:
sys.argv = oargs[:]
def test_run_fails(infopl):
"""Run fails"""
wf = Workflow()
def cb(wf2):
assert wf2 is wf
raise ValueError('Have an error')
wf.help_url = 'http://www.deanishe.net/alfred-workflow/'
ret = wf.run(cb)
assert ret == 1
# read name from info.plist
with env(alfred_workflow_name=None):
wf = Workflow()
wf.name
ret = wf.run(cb)
assert ret == 1
# named after bundleid
wf = Workflow()
wf.bundleid
ret = wf.run(cb)
assert ret == 1
wf.reset()
def test_update(self):
"""Magic: update"""
update_settings = {
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
}
wf = Workflow(update_settings=update_settings)
self.assertFalse(wf.update_available)
# Mock subprocess.call etc. so the script doesn't try to
# update the workflow in Alfred
c = WorkflowMock(['script', 'workflow:update'])
with c:
wf.args
wf.logger.debug('Magic update command : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
update_settings['version'] = 'v6.0'
wf = Workflow(update_settings=update_settings)
c = WorkflowMock(['script', 'workflow:update'])
with c:
wf.args
# Update command wasn't called
self.assertEqual(c.cmd, ())
def test_folding(self):
"""Magic: folding"""
wf = Workflow()
c = WorkflowMock(['script', 'workflow:foldingdefault'])
with c:
wf.args
self.assertIsNone(wf.settings.get('__workflow_diacritic_folding'))
wf = Workflow()
c = WorkflowMock(['script', 'workflow:foldingon'])
with c:
wf.args
self.assertTrue(wf.settings.get('__workflow_diacritic_folding'))
wf = Workflow()
c = WorkflowMock(['script', 'workflow:foldingdefault'])
with c:
wf.args
self.assertIsNone(wf.settings.get('__workflow_diacritic_folding'))
wf = Workflow()
c = WorkflowMock(['script', 'workflow:foldingoff'])
with c:
wf.args
self.assertFalse(wf.settings.get('__workflow_diacritic_folding'))
def test_cachedir_is_unicode(self):
"""Workflow.cachedir returns Unicode"""
wf = Workflow()
self.assertTrue(isinstance(wf.cachedir, unicode))
self._teardown_env()
wf = Workflow()
self.assertTrue(isinstance(wf.cachedir, unicode))
def test_cachefile_is_unicode(self):
"""Workflow.cachefile returns Unicode"""
wf = Workflow()
self.assertTrue(isinstance(wf.cachefile(b'test.txt'), unicode))
self.assertTrue(isinstance(wf.cachefile('über.txt'), unicode))
self._teardown_env()
wf = Workflow()
self.assertTrue(isinstance(wf.cachefile(b'test.txt'), unicode))
self.assertTrue(isinstance(wf.cachefile('über.txt'), unicode))
def WorkflowDetail(req, id, err=0):
v = getAdminStdVars(req)
if err == 0 and id == "":
# new workflow
workflow = Workflow(u"")
db.session.commit()
v["original_name"] = ""
elif id != "" and err == 0:
# edit workflow
workflow = getWorkflow(id)
v["original_name"] = workflow.name
else:
# error
workflow = Workflow(u"")
workflow.name = req.params.get("name", "")
workflow.set("description", req.params.get("description", ""))
#workflow.setAccess("write", req.params.get("writeaccess", ""))
v["original_name"] = req.params.get("orig_name", "")
workflow.id = req.params.get("id")
db.session.commit()
try:
rule = {
"read": [
r.ruleset_name
for r in workflow.access_ruleset_assocs.filter_by(
ruletype='read')
],
"write": [
r.ruleset_name
for r in workflow.access_ruleset_assocs.filter_by(
ruletype='write')
]
}
except:
rule = {"read": [], "write": []}
v["acl_read"] = makeList(req,
"read",
removeEmptyStrings(rule["read"]), {},
overload=0,
type="read")
v["acl_write"] = makeList(req,
"write",
removeEmptyStrings(rule["write"]), {},
overload=0,
type="write")
v["workflow"] = workflow
v["languages"] = config.languages
v["error"] = err
v["actpage"] = req.params.get("actpage")
v["csrf"] = req.csrf_token.current_token
return req.getTAL("web/admin/modules/workflows.html", v, macro="modify")
def test_alfred_debugger(self):
"""Alfred debugger status"""
wf = Workflow()
self.assertTrue(wf.debugging) # Alfred's debugger is open
self.assertEqual(wf.logger.getEffectiveLevel(), logging.DEBUG)
# With debugger off
self._teardown_env()
data = self.env_data.copy()
del data['alfred_debug']
self._setup_env(data)
wf = Workflow()
self.assertFalse(wf.debugging) # Alfred's debugger is closed
self.assertEqual(wf.logger.getEffectiveLevel(), logging.INFO)
def test_update(self):
"""Workflow update methods"""
# Initialise with outdated version
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
})
# Check won't have completed yet
self.assertFalse(wf.update_available)
# wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# There *is* a newer version in the repo
self.assertTrue(wf.update_available)
# Mock out subprocess and check the correct command is run
c = WorkflowMock()
with c:
self.assertTrue(wf.start_update())
# wf.logger.debug('start_update : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
# Grab the updated release data, then reset the cache
update_info = wf.cached_data('__workflow_update_status')
wf.reset()
# Initialise with latest available release
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': update_info['version'],
})
# Wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# Remove version is same as the one we passed to Workflow
self.assertFalse(wf.update_available)
self.assertFalse(wf.start_update())
def test_delete_settings(self):
"""Magic: delete settings"""
c = WorkflowMock(['script', 'workflow:delsettings'])
wf = Workflow()
wf.settings['key'] = 'value'
filepath = wf.datafile('settings.json')
with c:
self.assertTrue(os.path.exists(filepath))
wf2 = Workflow()
self.assertEquals(wf2.settings.get('key'), 'value')
# Process magic arguments
wf.args
self.assertFalse(os.path.exists(filepath))
wf3 = Workflow()
self.assertFalse('key' in wf3.settings)
def test_last_version_set_after_run(alfred4, infopl):
"""Workflow: last_version set after `run()`"""
vstr = '1.9.7'
def cb(wf):
return
with env(alfred_workflow_version=vstr):
wf = Workflow()
assert wf.last_version_run is None
wf.run(cb)
wf = Workflow()
assert wf.last_version_run == Version(vstr)
wf.reset()
def test_first_run_with_version(alfred4, infopl):
"""Workflow: first_run"""
vstr = '1.9.7'
with env(alfred_workflow_version=vstr):
wf = Workflow()
assert wf.first_run is True
wf.reset()
def createWorkflowYaml(yamlPath):
# Initialize workflow
workflow = Workflow()
# EXAMPLE AREA - DELETE BEFORE EXECUTION
# Create RawWriteStep
rawStep = RawWriteStep(workflow,
content=b'Testing',
description="Write test string",
position=1,
positionType=PositionType.SECTOR)
# Create step for loading boot sector from config file an write to disk
fatStep = FAT32CreateBootSectorStep(workflow,
pathToConfig=os.path.join(
os.path.dirname(yamlPath),
"fat32.yml"))
# Adding steps to workflow
workflow.addStep(rawStep)
workflow.addStep(fatStep)
# EXAMPLE AREA - DELETE BEFORE EXECUTION
# Write workflow to yaml config file
yaml = ruamel.yaml.YAML()
with open(yamlPath, 'w') as fout:
yaml.dump(workflow, fout)
def test_versions_from_info(alfred4, infopl):
"""Workflow: version from info.plist"""
with env(alfred_workflow_version=None):
wf = Workflow()
assert str(wf.version) == WORKFLOW_VERSION
assert isinstance(wf.version, Version)
assert wf.version == Version(WORKFLOW_VERSION)
def test_last_version_explicit_version(alfred4, infopl):
"""Workflow: last_version explicit version"""
vstr = '1.9.6'
wf = Workflow()
assert wf.set_last_version(vstr) is True
assert wf.last_version_run == Version(vstr)
wf.reset()
def test_last_version_set_after_run(self):
"""Workflow: last_version set after `run()`"""
vstr = '1.9.7'
def cb(wf):
return
with VersionFile(vstr):
with InfoPlist():
wf = Workflow()
self.assertTrue(wf.last_version_run is None)
wf.run(cb)
wf = Workflow()
self.assertEqual(wf.last_version_run, Version(vstr))
wf.reset()
def test_last_version_on(alfred4, infopl):
"""Workflow: last_version_run not empty"""
vstr = '1.9.7'
with env(alfred_workflow_version=vstr):
wf = Workflow()
wf.set_last_version(vstr)
assert Version(vstr) == wf.last_version_run
wf.reset()
# Set automatically
with env(alfred_workflow_version=vstr):
wf = Workflow()
wf.set_last_version()
assert Version(vstr) == wf.last_version_run
wf.reset()
def test_last_version_explicit_version(self):
"""Workflow: last_version explicit version"""
vstr = '1.9.6'
wf = Workflow()
self.assertTrue(wf.set_last_version(vstr))
self.assertEqual(wf.last_version_run, Version(vstr))
wf.reset()
def test_last_version_on(self):
"""Workflow: last_version_run not empty"""
vstr = '1.9.7'
with InfoPlist():
with VersionFile(vstr):
wf = Workflow()
wf.set_last_version(vstr)
self.assertEqual(Version(vstr), wf.last_version_run)
wf.reset()
# Set automatically
with VersionFile(vstr):
wf = Workflow()
wf.set_last_version()
self.assertEqual(Version(vstr), wf.last_version_run)
wf.reset()
def setUp(self):
self.libs = [os.path.join(os.path.dirname(__file__), 'lib')]
self.wf = Workflow(libraries=self.libs)
self.account = 'this-is-my-test-account'
self.password = '******'
self.password2 = 'this-is-my-other-safe-password'
self.search_items = [
('Test Item One', MATCH_STARTSWITH),
('test item two', MATCH_STARTSWITH),
('TwoExtraSpecialTests', MATCH_CAPITALS),
('this-is-a-test', MATCH_ATOM),
('the extra special trials', MATCH_INITIALS_STARTSWITH),
('not the extra special trials', MATCH_INITIALS_CONTAIN),
('intestinal fortitude', MATCH_SUBSTRING),
('the splits', MATCH_ALLCHARS),
('nomatch', 0),
]
self.search_items_diacritics = [
# search key, query
('Änderungen vorbehalten', 'av'),
('Änderungen', 'anderungen'),
('überwiegend bewolkt', 'ub'),
('überwiegend', 'uberwiegend'),
('Öffnungszeiten an Feiertagen', 'offnungszeiten'),
('Öffnungszeiten an Feiertagen', 'oaf'),
('Fußpilz', 'fuss'),
('salé', 'sale')
]
def test_versions_from_settings(self):
"""Workflow: version from `update_settings`"""
vstr = '1.9.7'
d = {'github_slug': 'deanishe/alfred-workflow', 'version': vstr}
wf = Workflow(update_settings=d)
self.assertEqual(str(wf.version), vstr)
self.assertTrue(isinstance(wf.version, Version))
self.assertEqual(wf.version, Version(vstr))
def test_open_term(self):
"""Magic: open Terminal"""
c = WorkflowMock(['script', 'workflow:openterm'])
with c:
wf = Workflow()
# Process magic arguments
wf.args
self.assertEquals(c.cmd, ['open', '-a', 'Terminal', wf.workflowdir])
def test_last_version_auto_version(alfred4, infopl):
"""Workflow: last_version auto version"""
vstr = '1.9.7'
with env(alfred_workflow_version=vstr):
wf = Workflow()
assert wf.set_last_version() is True
assert wf.last_version_run == Version(vstr)
wf.reset()
def test_info_plist_missing(self):
"""Info.plist missing"""
delete_info_plist()
try:
with self.assertRaises(IOError):
Workflow()
finally:
create_info_plist()
def test_first_run_with_version(self):
"""Workflow: first_run"""
vstr = '1.9.7'
with VersionFile(vstr):
with InfoPlist():
wf = Workflow()
self.assertTrue(wf.first_run)
wf.reset()
def test_alfred_debugger(alfred4):
"""Alfred debugger status"""
# With debugger on
with env(alfred_debug="1", PYTEST_RUNNING=None):
dump_env()
wf = Workflow()
assert wf.debugging, "Alfred's debugger not open"
assert wf.logger.getEffectiveLevel() == logging.DEBUG
wf.reset()
# With debugger off
with env(alfred_debug=None, PYTEST_RUNNING=None):
dump_env()
wf = Workflow()
assert not wf.debugging, "Alfred's debugger is not closed"
assert wf.logger.getEffectiveLevel() == logging.INFO
wf.reset()
def test_first_run_no_version(alfred4, infopl2):
"""Workflow: first_run fails on no version"""
with env(alfred_workflow_version=None):
wf = Workflow()
try:
with pytest.raises(ValueError):
wf.first_run
finally:
wf.reset()
def test_versions_from_file(alfred4, infopl2):
"""Workflow: version from `version` file"""
vstr = '1.9.7'
with env(alfred_workflow_version=None):
with VersionFile(vstr):
wf = Workflow()
assert str(wf.version) == vstr
assert isinstance(wf.version, Version)
assert wf.version == Version(vstr)
def test_versions_from_settings(alfred4, infopl2):
"""Workflow: version from `update_settings`"""
vstr = "1.9.7"
d = {"github_slug": "deanishe/alfred-workflow", "version": vstr}
with env(alfred_workflow_version=None):
wf = Workflow(update_settings=d)
assert str(wf.version) == vstr
assert isinstance(wf.version, Version)
assert wf.version == Version(vstr)
