def post(self):
# create a new plan
data = request.get_json()
if not data:
ret = {
'message': 'Provide data.',
}
return jsonify(ret), 422
plan = Plan(name=data['name'])
if data.get('clients'):
clients = [
Client.get(each_client) for each_client in data.get('clients')
]
plan.clients = filter(None, clients)
if data.get('days'):
days = [Day.query.get(each_day) for each_day in data.get('days')]
plan.days = filter(None, days)
db.session.add(plan)
db.session.commit()
db.session.refresh(plan)
ret = {
'id': plan.id,
'message': 'Plan created successfully.',
'name': data['name']
}
return jsonify(ret), 200
def create_plan():
form = forms.NewPlanForm(request.form)
if not form.validate():
flash("Error, all fields are required")
return render_template("new_plan.html")
if form.end_date.data < form.start_date.data:
flash("Error, end date can't be earlier than start date")
return render_template("new_plan.html")
url = generate_hash()
plan = Plan(name=form.name.data,
start_date=form.start_date.data,
end_date=form.end_date.data,
hashed_url=url)
if len(plan.date_range()) > 14:
flash("Error, this trip is too log. You can choose maximum 14 days")
return render_template("new_plan.html")
current_user.plans.append(plan)
for day in plan.date_range():
timeline = Timeline(date=day)
plan.timelines.append(timeline)
db.session.commit()
db.session.refresh(plan)
return redirect(url_for("view_plan", id=plan.id))
def manipulate_plan(conn, cursor, fmr, plan_fmt):
if plan_fmt['plan_name'] != fmr.plan_name:
if is_duplicate_plan(mysql, fmr.plan_name):
return short_error(err_list=['This plan is already exists'])
if plan_fmt['is_active']:
return short_error(err_list=['This plan is currently active'])
if is_expired_plan(mysql, fmr.plan_name):
return short_error(err_list=['This plan is expired and is read-only.'])
p = Plan(cursor, conn=conn)
p.update(fmr, plan_fmt['id'])
q_del = """DELETE FROM employee_plan WHERE ep_employee_FK = %s AND ep_plan_FK = %s"""
q_ins = """INSERT INTO employee_plan(ep_employee_FK, ep_plan_FK) VALUES (%s, %s)"""
uq = get_unique_employees(plan_fmt['employees_list'], fmr.employees_list)
if uq['operation'] == OperationType.DELETE_EMPLOYEE:
[
cursor.execute(q_del, (record['id'], plan_fmt['id']))
for record in uq['diff_list']
]
else:
[
cursor.execute(q_ins, (record['id'], plan_fmt['id']))
for record in uq['diff_list']
]
conn.commit()
conn.close()
return short_success(ManipulationType.UPDATED)
def plan(self, existing_events: Dict[Event, int],
desired_events: Set[Event]) -> Plan:
existing_event_set = set(existing_events.keys())
events_to_remove = existing_event_set - desired_events
events_to_add = desired_events - existing_event_set
ids_to_remove = {existing_events[event] for event in events_to_remove}
return Plan(to_remove=ids_to_remove, to_add=events_to_add)
def create_plan():
with DBSession() as session:
new = Plan(name=request.get_json().get("name"), content={})
session.add(new)
db_session().refresh(new)
return jsonify({
k: v
for k, v in new.__dict__.items()
if k in new._sa_instance_state.attrs.keys()
})
def test_pre_expiration_email(self):
resp_register = register_user_from_wp()
profile = ClientProfile.objects.all()[0]
plan1 = Plan(user=profile.user,
type=plans.TRIAL,
end_at=datetime.now() + timedelta(days=11),
status='active')
plan1.save()
c = Command()
c.handle()
subjects = [m.subject for m in mail.outbox]
self.assertTrue("It's almost that time" in subjects)
def init_db(Meal, Plan, User):
db.create_all()
user = User.query.filter_by(email='*****@*****.**').first()
if not user:
user = User(
alt_id=generate_alt_id(size=64),
alias='dummy',
email='*****@*****.**',
password=hash_password('password'),
)
plan = Plan(name='dummy plan', users=[user])
meal = Meal(
name='dummy meal',
created_date=datetime.datetime.utcnow(),
planned_date=to_date_int(datetime.date.today()),
plan=plan,
)
db.session.add(user)
db.session.add(meal)
db.session.commit()
def create_plan_execution(conn, cursor, fmr: Forminator):
if is_duplicate_plan(mysql, fmr.plan_name):
return short_error(err_list=[
'This plan already exists. Go to Manage Plan to learn more.'
])
if fmr.disbursement_type == fmr.raw_form.DISB_ALL:
employees = find_all_employees(cursor, session['manager_dept'])
if employees is None:
return short_error(
err_list=['No employees were found in the department'])
fmr.employees_list = employees['data']
p = Plan(cursor, conn=conn)
p.insert(fmr)
conn.close()
execute_orders()
return short_success(ManipulationType.CREATED)
from models import Plan
from pydantic import BaseModel, ValidationError, validator, PydanticValueError
try:
Plan()
except ValidationError as e:
print("JSON representation")
print("-------------------")
print(e.json(), end="\n\n")
print("Python representation")
print("---------------------")
print(e.errors(), end="\n\n")
print("Human readable")
print("--------------")
print(str(e))
"""
JSON representation
-------------------
[
{
"loc": [
"base"
],
"msg": "field required",
"type": "value_error.missing"
},
{
"loc": [
"usage"
def submit_make(request):
if os.environ.get("TEST", None):
request.session["userId"] = request.GET["userId"]
if not "userId" in request.session:
return HttpResponseRedirect("/static/not_bind.html")
if not "userId" in request.POST:
return HttpResponseRedirect("/static/404.html")
if not request.POST["userId"] == request.session["userId"]:
return HttpResponseRedirect("/static/404.html")
try:
userId = request.POST["userId"]
user = User.objects.get(openId=userId)
now = basic_tools.getNow()
plan = Plan(name=request.POST["plan_name"],
description=request.POST["comment"],
createTime=now,
startTime=basic_tools.DateToInt(
"%s:00:00" % request.POST["begintime"][:13]),
endTime=basic_tools.DateToInt(
"%s:00:00" % request.POST["endtime"][:13]),
owner=user)
if request.POST["goal"] == "":
goal = 0
else:
goal = int(request.POST["goal"])
plan.goal = goal
plan.save()
if goal > 0:
progress = PlanProgress(plan=plan, user=user)
progress.save()
tags = []
tag = request.POST["tags"]
if not tag == "":
item = PTag.objects.filter(name=tag)
if len(item) == 0:
item = PTag(name=tag)
item.save()
else:
item = item[0]
if not item.plans.filter(id=plan.id).exists():
tags.append(tag)
item.plans.add(plan)
i = 0
while ("tag%d" % i) in request.POST:
tag = request.POST["tag%d" % i]
i += 1
if not tag == "":
item = PTag.objects.filter(name=tag)
if len(item) == 0:
item = PTag(name=tag)
item.save()
else:
item = item[0]
if not item.plans.filter(id=plan.id).exists():
tags.append(tag)
item.plans.add(plan)
if len(tags) == 0 and goal > 0:
tag = "%d步" % goal
item = PTag.objects.filter(name=tag)
if len(item) == 0:
item = PTag(name=tag)
item.save()
else:
item = item[0]
if not item.plans.filter(id=plan.id).exists():
tags.append(tag)
item.plans.add(plan)
prefix = os.environ.get("WRIST_HOME")
path = "/media/plan/"
if not os.path.exists(prefix + path):
os.mkdir(prefix + path)
if "image" in request.FILES:
file = request.FILES["image"]
file_name = "%s%s_%s_%s" % (path, plan.name.encode("utf-8"),
str(now), file.name.encode("utf-8"))
des = open(prefix + file_name, "wb")
for chunk in file.chunks():
des.write(chunk)
des.close()
else:
file_name = tools.getDefaultImageByTag(tags)
plan.image = file_name
plan.save()
plan.members.add(user)
i = 0
while ("friend%d" % i) in request.POST:
tools.sendInvite(user, plan.id, request.POST["friend%d" % i])
i += 1
return HttpResponseRedirect("/plan/redirect/profile?page=4&id=%d" %
plan.id)
except:
return HttpResponseRedirect("/static/404.html")
