def template():
form = TemplateForm()
if form.validate_on_submit():
data = form.data
print("this is submitted")
if data.get('name') is None:
flash("为你的模板输入一个名字!", "err")
return redirect(url_for('admin.template'))
if data.get('css') is None:
flash("一个模板增加css文件吧，不然太没文艺感了!", "err")
return redirect(url_for('admin.template'))
if data.get('html') is None:
flash("一个模板HTML文件都不加？", "err")
return redirect(url_for('admin.template'))
template = Template(name=data.get("name"),
css=data.get("css"),
html=data.get("html"),
js=data.get("js"),
category=data.get('category'),
order=data.get('order'))
db.session.add(template)
db.session.commit()
flash("添加模板成功！", "ok")
return redirect(url_for('admin.template'))
return render_template('admin/template.html', form=form)
def add_workflows_to_db(obj, message):
for o in obj:
t = Template()
if 'name' in o:
t.name = o['name']
if 'steps' in o:
# Query for steps and associate them with template
for step in o['steps']:
step_object = Step.objects.filter(name=step).first()
if step_object:
t['steps'].append(step_object)
else:
print('No step object found')
try:
t.save()
except ValidationError as e:
message.append('Error creating the template: ' + str(e))
pass
except NotUniqueError:
message.append(
'Template with the name "{0}" has already been added.'.format(
o['name']))
pass
except:
message.append('There was an error creating a template')
pass
return message
def new_template():
if request.method == 'POST':
form = Template_view()
filename = ''
file_path = ''
try:
file = request.files['template_file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(
os.path.join(app.config['UPLOAD_FOLDER'],
app.config['TEMPLATES_FOLDER'], filename))
file_path = os.path.join(app.config['UPLOAD_FOLDER'],
app.config['TEMPLATES_FOLDER'],
filename)
except:
pass
template = Template(name=form.name.data,
status=form.status.data,
file_name=filename,
file_path=file_path)
db.session.add(template)
db.session.commit()
return redirect(url_for('templates'))
elif request.method == 'GET':
form = Template_view()
form.status.choices = [(s.id, s.name)
for s in Status.query.order_by('name')]
return render_template('new_template.html',
title='Создание нового шаблона',
form=form)
def test_dao_update_template_reply_to_some_to_none(sample_service,
sample_user):
letter_contact = create_letter_contact(sample_service,
"Edinburgh, ED1 1AA")
data = {
"name": "Sample Template",
"template_type": "letter",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
"service_letter_contact_id": letter_contact.id,
"postage": "second",
}
template = Template(**data)
dao_create_template(template)
created = Template.query.get(template.id)
dao_update_template_reply_to(template_id=created.id, reply_to=None)
updated = Template.query.get(template.id)
assert updated.reply_to is None
assert updated.version == 2
assert updated.updated_at
history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
assert history.service_letter_contact_id is None
assert history.updated_at == updated.updated_at
def test_dao_update_template_reply_to_some_to_some(sample_service, sample_user):
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
letter_contact_2 = create_letter_contact(sample_service, 'London, N1 1DE')
data = {
'name': 'Sample Template',
'template_type': "letter",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'service_letter_contact_id': letter_contact.id,
'postage': 'second',
}
template = Template(**data)
dao_create_template(template)
created = Template.query.get(template.id)
dao_update_template_reply_to(template_id=created.id, reply_to=letter_contact_2.id)
updated = Template.query.get(template.id)
assert updated.reply_to == letter_contact_2.id
assert updated.version == 2
assert updated.updated_at
updated_history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
assert updated_history.service_letter_contact_id == letter_contact_2.id
assert updated_history.updated_at == updated_history.updated_at
def create_template_model(
service,
template_type=EMAIL_TYPE,
template_name=None,
subject='Template subject',
content='Dear Sir/Madam, Hello. Yours Truly, The Government.',
reply_to=None,
hidden=False,
folder=None,
process_type='normal',
):
data = {
'id': uuid.uuid4(),
'name': template_name or '{} Template Name'.format(template_type),
'template_type': template_type,
'content': content,
'service': service,
'created_by': service.created_by,
'reply_to': reply_to,
'hidden': hidden,
'folder': folder,
'process_type': process_type
}
if template_type != SMS_TYPE:
data['subject'] = subject
template = Template(**data)
return template
def sample_email_template(
notify_db,
notify_db_session,
template_name="Email Template Name",
template_type="email",
user=None,
content="This is a template",
subject_line="Email Subject",
service=None,
permissions=[EMAIL_TYPE, SMS_TYPE],
):
if user is None:
user = create_user()
if service is None:
service = create_service(
user=user,
service_permissions=permissions,
check_if_service_exists=True,
)
data = {
"name": template_name,
"template_type": template_type,
"content": content,
"service": service,
"created_by": user,
"subject": subject_line,
}
template = Template(**data)
dao_create_template(template)
return template
def test_update_template_creates_a_history_record_with_current_data(
sample_service, sample_user):
assert Template.query.count() == 0
assert TemplateHistory.query.count() == 0
data = {
"name": "Sample Template",
"template_type": "email",
"subject": "subject",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == "Sample Template"
assert Template.query.count() == 1
assert Template.query.first().version == 1
assert TemplateHistory.query.count() == 1
created.name = "new name"
dao_update_template(created)
assert Template.query.count() == 1
assert TemplateHistory.query.count() == 2
template_from_db = Template.query.first()
assert template_from_db.version == 2
assert TemplateHistory.query.filter_by(
name="Sample Template").one().version == 1
assert TemplateHistory.query.filter_by(name="new name").one().version == 2
def test_update_template_in_a_folder_to_archived(sample_service, sample_user):
template_data = {
'name': 'Sample Template',
'template_type': "sms",
'content': "Template content",
'service': sample_service,
'created_by': sample_user
}
template = Template(**template_data)
template_folder_data = {
'name': 'My Folder',
'service_id': sample_service.id,
}
template_folder = TemplateFolder(**template_folder_data)
template.folder = template_folder
dao_create_template(template)
template.archived = True
dao_update_template(template)
template_folder = TemplateFolder.query.one()
archived_template = Template.query.one()
assert template_folder
assert not archived_template.folder
def sample_email_template(notify_db,
notify_db_session,
template_name="Email Template Name",
template_type="email",
user=None,
content="This is a template",
subject_line='Email Subject',
service=None,
permissions=[EMAIL_TYPE, SMS_TYPE]):
if user is None:
user = create_user()
if service is None:
service = create_service(user=user,
service_permissions=permissions,
check_if_service_exists=True,
smtp_user="******")
data = {
'name': template_name,
'template_type': template_type,
'content': content,
'service': service,
'created_by': user,
'subject': subject_line
}
template = Template(**data)
dao_create_template(template)
return template
def test_update_template_creates_a_history_record_with_current_data(sample_service, sample_user):
assert Template.query.count() == 0
assert TemplateHistory.query.count() == 0
data = {
'name': 'Sample Template',
'template_type': "email",
'subject': "subject",
'content': "Template content",
'service': sample_service,
'created_by': sample_user
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == 'Sample Template'
assert Template.query.count() == 1
assert Template.query.first().version == 1
assert TemplateHistory.query.count() == 1
created.name = 'new name'
dao_update_template(created)
assert Template.query.count() == 1
assert TemplateHistory.query.count() == 2
template_from_db = Template.query.first()
assert template_from_db.version == 2
assert TemplateHistory.query.filter_by(name='Sample Template').one().version == 1
assert TemplateHistory.query.filter_by(name='new name').one().version == 2
def test_create_template_creates_a_history_record_with_current_data(
sample_service, sample_user):
assert Template.query.count() == 0
assert TemplateHistory.query.count() == 0
data = {
"name": "Sample Template",
"template_type": "email",
"subject": "subject",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
}
template = Template(**data)
dao_create_template(template)
assert Template.query.count() == 1
template_from_db = Template.query.first()
template_history = TemplateHistory.query.first()
assert template_from_db.id == template_history.id
assert template_from_db.name == template_history.name
assert template_from_db.version == 1
assert template_from_db.version == template_history.version
assert sample_user.id == template_history.created_by_id
assert template_from_db.created_by.id == template_history.created_by_id
def post(self):
data = json.loads(request.data.decode())
existing = Template.query.filter_by(name=data["name"])
try:
if existing.first():
raise InvalidUsage("Template exists")
except InvalidUsage as error:
response = Response(json.dumps(error.to_dict()))
response.status_code = error.status_code
return response
t = Template(name=data["name"], content=data["content"])
save_models([t])
try:
is_default = strtobool(data.get('default') or "false")
except ValueError as error:
message = dict({"Error": str(error)})
response = Response(json.dumps(message, indent=4), content_type="application/json")
response.status_code = 500
return response
if is_default:
try:
dt = DefaultTemplate.query.one()
except:
dt = DefaultTemplate()
dt.template_id = t.id
save_models([dt])
return list_templates()
def test_create_template_creates_a_history_record_with_current_data(sample_service, sample_user):
assert Template.query.count() == 0
assert TemplateHistory.query.count() == 0
data = {
'name': 'Sample Template',
'template_type': "email",
'subject': "subject",
'content': "Template content",
'service': sample_service,
'created_by': sample_user
}
template = Template(**data)
dao_create_template(template)
assert Template.query.count() == 1
template_from_db = Template.query.first()
template_history = TemplateHistory.query.first()
assert template_from_db.id == template_history.id
assert template_from_db.name == template_history.name
assert template_from_db.version == 1
assert template_from_db.version == template_history.version
assert sample_user.id == template_history.created_by_id
assert template_from_db.created_by.id == template_history.created_by_id
def test_update_template_in_a_folder_to_archived(sample_service, sample_user):
template_data = {
"name": "Sample Template",
"template_type": "sms",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
}
template = Template(**template_data)
template_folder_data = {
"name": "My Folder",
"service_id": sample_service.id,
}
template_folder = TemplateFolder(**template_folder_data)
template.folder = template_folder
dao_create_template(template)
template.archived = True
dao_update_template(template)
template_folder = TemplateFolder.query.one()
archived_template = Template.query.one()
assert template_folder
assert not archived_template.folder
def modify_task_info():
if not current_user.is_active:
headers = request.headers
se = Session.query.filter_by(sid=int(headers['session_id']),
uid=int(headers['user_id'])).first()
if se == None:
print('session is not connected')
return json.dumps({'errmsg': '没有建立会话或者会话信息出错'})
user = User.query.filter_by(id=se.uid).first()
login_user(user)
if request.method == 'POST':
json_data = json.loads(request.data)
if 'id' in json_data:
#查询task
task = Task.query.filter_by(id=json_data['id']).first()
print(task)
#如果任务已经进行则无法修改
if task.state != 0:
return json.dumps({'errmsg': '任务已在进行中，无法修改'})
#先记录之前的费用
former_pay = task.pay * task.receiver_limit
#修改基础信息
task.title = json_data[
'title'] if 'title' in json_data else task.title
task.type = json_data['type'] if 'type' in json_data else task.type
task.pay = json_data['pay'] if 'pay' in json_data else task.pay
task.detail = json_data[
'detail'] if 'detail' in json_data else task.detail
task.receiver_limit = json_data[
'receiver_limit'] if 'receiver_limit' in json_data else task.receiver_limit
task.received_number = json_data[
'received_number'] if 'received_number' in json_data else task.received_number
task.extra_content = json_data[
'extra_content'] if 'extra_content' in json_data else task.extra_content
#重新收取费用
paySum = task.pay * task.receiver_limit
current_user.exMoney = current_user.exMoney + former_pay - paySum
current_user.expend = current_user.expend - former_pay + paySum
#重新建立任务模板
task.template = Template()
task.template.questions = json_data[
'questions'] if 'questions' in json_data else []
task.template.options = json_data[
'options'] if 'options' in json_data else []
task.template.types = json_data[
'types'] if 'types' in json_data else []
db.session.commit()
return json.dumps(task.id)
return json.dumps({'errmsg': '没有指定任务'})
return json.dumps({'errmsg': '没有使用POST请求'})
def new_template():
"""Add a new app template."""
# Set the form for this page
form = TemplateForm(request.form)
if form.validate_on_submit():
# Check the file type and depending on the file, download it and add it
# to the db.
template_name = form.template_name.data
template_url = form.template_url.data
template = Template(
name=template_name,
url=template_url,
)
# Break down template into individual apps and then put their data into
# the db for later use.
try:
# Opens the JSON and iterate over the content.
with urllib.request.urlopen(template_url) as file:
for entry in json.load(file):
ports = conv_ports2dict(entry.get('ports', []))
# Optional use classmethod from_dict
template_content = TemplateContent(
type=int(entry['type']),
title=entry['title'],
platform=entry['platform'],
description=entry.get('description', ''),
name=entry.get('name', entry['title'].lower()),
logo=entry.get('logo', ''),
image=entry.get('image', ''),
notes=entry.get('note', ''),
categories=entry.get('categories',
''), # default: '' or []
restart_policy=entry.get('restart_policy'),
sysctls=entry.get('sysctls'),
ports=ports,
volumes=entry.get('volumes'),
env=entry.get('env'),
)
template.items.append(template_content)
except (OSError, TypeError, ValueError) as err:
# Optional handle KeyError here too.
print('data request failed', err)
raise
try:
db.session.add(template)
db.session.commit()
except SQLAlchemyError as err:
print('database transaction failed')
db.session.rollback()
raise
return redirect(url_for('templates.index'))
return render_template('app_templates/new_template.html', form=form)
def post(self):
args = post_parser.parse_args()
result = Template.query.filter_by(descripcion=args.descripcion).count()
if(result>0):
abort(404, message="{} ya existe".format(args.descripcion))
newData = Template(
descripcion = args.descripcion,
body = args.body
)
db.session.add(newData)
db.session.commit()
return newData,201
def test_template_postage_constraint_on_create(sample_service, sample_user, template_type, postage):
data = {
'name': 'Sample Template',
'template_type': template_type,
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'postage': postage
}
template = Template(**data)
with pytest.raises(expected_exception=SQLAlchemyError):
dao_create_template(template)
def test_template_with_no_given_provider_id_has_null_provider_id(sample_service, sample_user):
data = {
'name': 'Sample Template',
'template_type': "email",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
}
template = Template(**data)
dao_create_template(template)
assert Template.query.filter_by(id=template.id).one().provider_id is None
def test_template_postage_constraint_on_create(sample_service, sample_user,
template_type, postage):
data = {
"name": "Sample Template",
"template_type": template_type,
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
"postage": postage,
}
template = Template(**data)
with pytest.raises(expected_exception=SQLAlchemyError):
dao_create_template(template)
def sample_email_template(notify_db_session):
user = create_user()
service = create_service(user=user, service_permissions=[EMAIL_TYPE, SMS_TYPE], check_if_service_exists=True)
data = {
'name': 'Email Template Name',
'template_type': EMAIL_TYPE,
'content': 'This is a template',
'service': service,
'created_by': user,
'subject': 'Email Subject'
}
template = Template(**data)
dao_create_template(template)
return template
def template():
id = request.json.get('id')
title = request.json.get('title')
para1 = request.json.get('para1')
para2 = request.json.get('para2')
para3 = request.json.get('para3')
if request.method == 'PUT':
new_title = request.json.get('title')
new_para1 = request.json.get('para1')
new_para2 = request.json.get('para2')
new_para3 = request.json.get('para3')
admin = Template.query.filter_by(id=id).first()
admin.Title = new_title
admin.para1 = new_para1
admin.para2 = new_para2
admin.para3 = new_para3
db.session.add(admin)
db.session.commit()
return 'updated template'
#Get Method
elif request.method == 'GET':
template = Template.query.filter_by(id=id).first()
print(Template)
print(template)
print('adfsgarw,fjshdlfjhwgfliu')
return "<h1><center>{}</center></h1> \
<p>{}</p> \
<p>{}</p> \
<p>{}</p>".format(template.Title, template.para1,
template.para2, template.para3)
#Delete Method
elif request.method == 'DELETE':
template = Template.query.filter_by(Title=title,
para1=para1,
para2=para2,
para3=para3)
db.session.delete(template.first())
db.session.commit()
return 'successful deletion of template'
#Post Method
elif request.method == 'POST':
template = Template(Title=title, para1=para1, para2=para2, para3=para3)
try:
db.session.add(template)
db.session.commit()
except IntegrityError:
raise customException2
return 'Created template'
def test_template_with_provider_id_persists_provider_id(sample_service, sample_user, ses_provider):
data = {
'name': 'Sample Template',
'template_type': "email",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'provider_id': ses_provider.id
}
template = Template(**data)
dao_create_template(template)
assert Template.query.filter_by(id=template.id).one().provider_id == ses_provider.id
def test_create_template_with_reply_to(sample_service, sample_user):
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
data = {
'name': 'Sample Template',
'template_type': "letter",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'reply_to': letter_contact.id,
}
template = Template(**data)
dao_create_template(template)
assert dao_get_all_templates_for_service(sample_service.id)[0].reply_to == letter_contact.id
def test_create_template(notify_api, notify_db, notify_db_session,
sample_service):
assert Template.query.count() == 0
template_name = 'Sample Template'
data = {
'name': template_name,
'template_type': "sms",
'content': "Template content",
'service': sample_service
}
template = Template(**data)
save_model_template(template)
assert Template.query.count() == 1
assert Template.query.first().name == template_name
assert Template.query.first().id == template.id
def test_update_template(sample_service, sample_user):
data = {
'name': 'Sample Template',
'template_type': "sms",
'content': "Template content",
'service': sample_service,
'created_by': sample_user
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == 'Sample Template'
created.name = 'new name'
dao_update_template(created)
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'new name'
def test_template_postage_constraint_on_update(sample_service, sample_user):
data = {
"name": "Sample Template",
"template_type": "letter",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
"postage": "second",
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == "Sample Template"
created.postage = "third"
with pytest.raises(expected_exception=SQLAlchemyError):
dao_update_template(created)
def test_template_postage_constraint_on_update(sample_service, sample_user):
data = {
'name': 'Sample Template',
'template_type': "letter",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'postage': 'second'
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == 'Sample Template'
created.postage = 'third'
with pytest.raises(expected_exception=SQLAlchemyError):
dao_update_template(created)
def test_update_template(sample_service, sample_user):
data = {
"name": "Sample Template",
"template_type": "sms",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == "Sample Template"
created.name = "new name"
dao_update_template(created)
assert dao_get_all_templates_for_service(
sample_service.id)[0].name == "new name"