def add_agroup_id_filter(self, kwargs):
associate_group_id = current_user.associate_group_id
if is_region_role() and associate_group_id:
kwargs['where'] += \
(self.manager.filters['associate_group_id'][None].convert(
associate_group_id),)
kwargs['filter_and_cols'] = ['associate_group_id']
text_search = request.args.get('text_search')
if text_search and text_search != 'false':
provinces_id = [
p.province_id for p in models.Province.query.filter(
models.Province.name.contains(text_search)).all()]
kwargs['where'] += \
(self.manager.filters['province_id']['in'].convert(
{'$in': provinces_id}),)
districts_id = [
d.district_id for d in models.District.query.filter(
models.District.name.contains(text_search)).all()]
kwargs['where'] += \
(self.manager.filters['district_id']['in'].convert(
{'$in': districts_id}),)
wards_id = [p.ward_id for p in models.Ward.query.filter(
models.Ward.name.contains(text_search)).all()]
kwargs['where'] += \
(self.manager.filters['ward_id']['in'].convert(
{'$in': wards_id}),)
if not is_region_role() or not associate_group_id:
agroups_id = [p.id for p in models.AssociateGroup.query.filter(
models.AssociateGroup.name.contains(text_search)).all()]
kwargs['where'] += \
(self.manager.filters['associate_group_id']['in'].convert(
{'$in': agroups_id}),)
def area(self) -> fields.String():
approved = request.args.get('approved')
if approved == 'True' or approved == 'true':
approved = True
else:
approved = False
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
gs = [g.id for g in models.Group.query.filter_by(
associate_group_id=associate_group_id, _deleted_at=None).all()]
else:
gs = [g.id for g in models.Group.query.filter_by(
_deleted_at=None).all()]
sum = 0
today = datetime.date.today()
for g in gs:
cs = models.Certificate.query.filter_by(
owner_group_id=g, _deleted_at=None).all()
for cert in cs:
if cert.certificate_expiry_date and \
cert.certificate_expiry_date >= today:
if approved and cert.re_verify_status == \
c.CertificateReVerifyStatusType.adding and \
cert.status == \
c.CertificateStatusType.approved:
sum += cert.group_area
if not approved and \
(cert.re_verify_status ==
c.CertificateReVerifyStatusType.adding or
cert.re_verify_status ==
c.CertificateReVerifyStatusType.converting):
sum += cert.group_area
return sum
def add_filter_associate_group_id(self, kwargs):
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
gs = [g.id for g in models.Group.query.filter_by(
associate_group_id=associate_group_id,
_deleted_at=None).all()]
for cond in kwargs['where']:
if cond.attribute == 'group_id' and isinstance(
cond.filter, filters.InFilter):
value = []
for val in cond.value:
if val in gs:
value.append(val)
cond.value = value
kwargs['where'] += \
(self.manager.filters['group_id']['in'].convert(
{'$in': gs}),)
kwargs['filter_and_cols'] = ['group_id']
else:
text_search = request.args.get('text_search')
if text_search and text_search != 'false':
groups_id = [g.id for g in models.Group.query.filter(
models.Group.name.contains(text_search)).all()]
kwargs['where'] += \
(self.manager.filters['group_id']['in'].convert(
{'$in': groups_id}),)
return kwargs
def _filter_group_farmer_on_associate_group(self, kwargs,
is_cert_for_group=False, is_cert_for_farmer=False):
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
kwargs['filter_and_cols'] = ['associate_group_id']
gs = [g.id for g in models.Group.query.filter_by(
associate_group_id=associate_group_id, _deleted_at=None).all()]
fs = [f.id for f in models.Farmer.query.join(models.Group).filter(
models.Group.associate_group_id == associate_group_id,
models.Group._deleted_at == None,
models.Farmer._deleted_at == None).all()]
group_filter_exist = False
farmer_filter_exist = False
if is_cert_for_group:
kwargs['where'] += \
(self.manager.filters['owner_group_id']['in'].convert(
{'$in': gs}),)
elif is_cert_for_farmer:
kwargs['where'] += \
(self.manager.filters['owner_farmer_id']['in'].convert(
{'$in': fs}),)
else:
for cond in kwargs['where']:
if cond.attribute == 'owner_group_id' and isinstance(
cond.filter, filters.InFilter):
value = []
for val in cond.value:
if val in gs:
value.append(val)
cond.value = value
elif not group_filter_exist:
kwargs['where'] += \
(self.manager.filters['owner_group_id']['in']
.convert({'$in': gs}),)
group_filter_exist = True
if cond.attribute == 'owner_farmer_id' and isinstance(
cond.filter, filters.InFilter):
value = []
for val in cond.value:
if val in fs:
value.append(val)
cond.value = value
elif not farmer_filter_exist:
kwargs['where'] += \
(self.manager.filters['owner_farmer_id']['in']
.convert({'$in': fs}),)
farmer_filter_exist = True
if len(kwargs['where']) == 0:
kwargs['where'] += \
(self.manager.filters['owner_group_id']['in'].convert(
{'$in': gs}),)
kwargs['where'] += \
(self.manager.filters['owner_farmer_id']['in'].convert(
{'$in': fs}),)
def select2_api(self, **kwargs):
kwargs['where'] += \
(self.manager.filters['_deleted_at'][None].convert(None),)
associate_group_id = current_user.associate_group_id
if is_region_role() and associate_group_id:
kwargs['where'] += \
(self.manager.filters['associate_group_id'][None].convert(
associate_group_id),)
del kwargs['per_page']
del kwargs['page']
return self.manager.instances(**kwargs)
def gender(self) -> fields.String():
gender = int(request.args.get('type'))
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
gs = [g.id for g in models.Group.query.filter_by(
associate_group_id=associate_group_id, _deleted_at=None).all()]
else:
gs = [g.id for g in models.Group.query.filter_by(
_deleted_at=None).all()]
sum = 0
for g in gs:
count = models.Farmer.query.filter_by(
group_id=g, _deleted_at=None, gender=gender).all()
sum += len(count)
return sum
def check_user_associate_group(manager, kwargs, is_and=False, is_delete=True,
is_agroup_id=True, is_get_all=False):
if is_get_all:
func = manager.instances
elif len(kwargs['where']) == 0 or is_and:
func = manager.paginated_instances
else:
func = manager.paginated_instances_or
associate_group_id = current_user.associate_group_id
if is_region_role() and associate_group_id and is_agroup_id:
kwargs['where'] += \
(manager.filters['id'][None].convert(
associate_group_id),)
if is_delete:
kwargs['where'] += \
(manager.filters['_deleted_at'][None].convert(None),)
return func
def instances(self, **kwargs):
associate_group_id = current_user.associate_group_id
if is_region_role() and associate_group_id:
kwargs['where'] += \
(self.manager.filters['associate_group_id'][None].convert(
associate_group_id),)
kwargs['filter_and_cols'] = ['associate_group_id']
else:
text_search = request.args.get('text_search')
if text_search and text_search != 'false':
agroups_id = [
ag.id for ag in models.AssociateGroup.query.filter(
models.AssociateGroup.name.contains(
text_search)).all()]
kwargs['where'] += \
(self.manager.filters['associate_group_id']['in'].convert(
{'$in': agroups_id}),)
kwargs['filter_and_cols'] = ['associate_group_id']
func = check_user_associate_group(self.manager,
kwargs, is_delete=False,
is_agroup_id=False)
return func(**kwargs)
def users():
form = UserForm()
dform = DeleteForm()
form.roles.choices = [
(r.name, r.description)
for r in models.Role.query.order_by(models.Role.name.asc()).all()
]
if current_app.config['AJAX_CALL_ENABLED']:
form.associate_group_id.choices = []
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
form.associate_group_id.choices = [
(ag.id, ag.name)
for ag in models.AssociateGroup.query.filter_by(
id=associate_group_id).all()
]
return render_template('admin/user.html', form=form, dform=dform)
else:
province_id = current_user.province_id
if province_id and is_region_role():
us = models.User.query.filter_by(province_id=province_id).all()
form.province_id.choices = [
(p.province_id, p.type + " " + p.name)
for p in models.Province.query.filter_by(
province_id=province_id).all()
]
else:
us = models.User.query.all()
form.province_id.choices = []
# form create or edit submit
if request.method == 'POST' and form.data['submit']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
form.province_id.choices = [(form.province_id.data,
form.province_id.label.text)]
# edit user
if form.id.data:
# remove required validator in fields pass and confirm
# when form is edit form
setattr(form.password, 'validators', [match_pass])
setattr(form.confirm, 'validators', [])
if form.validate_on_submit():
edit_user = user_datastore.find_user(id=form.id.data)
if form.old_password.data:
if not security_utils.verify_and_update_password(
form.old_password.data, edit_user):
flash(str(__('Old password is wrong!')), 'error')
# TODO: fix return to keep current state of form
return redirect(url_for(request.endpoint))
else:
edit_user.password = security_utils.hash_password(
form.password.data)
temp_user = sqla.session.query(models.User) \
.filter_by(email=form.email.data).all()
if not check_user_email(temp_user, edit_user.email):
form.email.errors.append(__('The email was existed!'))
flash(str(__('The email was existed!')), 'error')
else:
edit_user.email = form.email.data
edit_user.fullname = form.fullname.data
if form.province_id.data != edit_user.province_id:
edit_user.province = models.Province.query \
.filter_by(province_id=form.province_id.data) \
.one()
for new_role in form.roles.data:
role_is_added = False
for r in edit_user.roles:
if new_role == r.name:
role_is_added = True
break
if not role_is_added:
user_datastore.add_role_to_user(
edit_user.email, new_role)
temp_roles = list(edit_user.roles)
for old_role in temp_roles:
if old_role.name not in form.roles.data:
user_datastore.remove_role_from_user(
edit_user.email, old_role.name)
user_datastore.put(edit_user)
for user in us:
if user.id == edit_user.id:
us.remove(user)
us.append(edit_user)
flash(str(__('Update user success!')), 'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# add user
else:
setattr(form.password, 'validators',
[data_required, match_pass])
setattr(form.confirm, 'validators', [data_required])
form.id.data = str(uuid.uuid4())
if form.validate_on_submit():
if not user_datastore.find_user(email=form.email.data):
province = models.Province.query.filter_by(
province_id=form.province_id.data).one()
user_datastore.create_user(
id=form.id.data,
email=form.email.data,
fullname=form.fullname.data,
province=province,
password=security_utils.hash_password(
form.password.data))
sqla.session.commit()
for role in form.roles.data:
user_datastore.add_role_to_user(
form.email.data, role)
sqla.session.commit()
flash(str(__('Add user success!')), 'success')
return redirect(url_for(request.endpoint))
else:
form.email.errors.append(__('The email was existed!'))
flash(str(__('The email was existed!')), 'error')
else:
flash(str(__('The form is not validated!')), 'error')
# form delete submit
if request.method == 'POST' and dform.data['submit_del']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
elif dform.validate_on_submit():
del_user = user_datastore.find_user(id=dform.id.data)
user_datastore.delete_user(del_user)
sqla.session.commit()
flash(str(__('Delete user success!')), 'success')
return redirect(url_for(request.endpoint))
return render_template('admin/user.html',
us=us,
form=form,
dform=dform)
def farmers():
form = CertificateForm()
dform = DeleteForm()
if current_app.config['AJAX_CALL_ENABLED']:
form.owner_farmer_id.choices = []
form.owner_group_id.choices = []
return render_template('certificate/index.html',
form=form,
dform=dform,
only_farmer=True)
else:
province_id = current_user.province_id
today = datetime.datetime.today().strftime('%Y-%m-%d')
if province_id and is_region_role():
cs = []
tmp_cs = models.Certificate.query.join(models.Farmer).filter(
models.Farmer._deleted_at == None,
models.Certificate.owner_farmer_id != None,
models.Certificate._deleted_at == None,
or_(models.Certificate.certificate_expiry_date >= today,
models.Certificate.certificate_expiry_date == None)).all()
for cert in tmp_cs:
if cert.owner_farmer.group.province_id == province_id:
cs.append(cert)
del form.owner_group_id
form.owner_farmer_id.choices = [
(f.id, f.name)
for f in models.Farmer.query.join(models.Group).filter(
models.Group._deleted_at == None, models.Farmer._deleted_at
== None).order_by(models.Farmer.name.asc()).all()
]
else:
cs = models.Certificate.query.filter(
models.Certificate.owner_farmer_id != None,
models.Certificate._deleted_at == None,
or_(models.Certificate.certificate_expiry_date >= today,
models.Certificate.certificate_expiry_date == None)).all()
form.owner_farmer_id.choices = []
del form.owner_group_id
# form create or edit submit
if request.method == 'POST' and form.data['submit']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
form.owner_farmer_id.choices = [(form.owner_farmer_id.data,
form.owner_farmer_id.label.text)]
form.owner_group_id.choices = [(form.owner_group_id.data,
form.owner_group_id.label.text)]
# edit certificate
if form.id.data:
if form.validate_on_submit():
start_date = form.certificate_start_date.data
expiry_date = form.certificate_expiry_date.data
if start_date > expiry_date:
form.certificate_expiry_date.errors.append(
__('The expiry date must greater than start date'))
flash((str(
__('The expiry date must greater than '
'start date!'))), 'error')
else:
edit_certificate = sqla.session \
.query(models.Certificate) \
.filter_by(id=form.id.data).one()
edit_certificate.certificate_code = form \
.certificate_code.data
edit_certificate.group_area = form.group_area.data
edit_certificate.member_count = form.member_count.data
edit_certificate.certificate_start_date = start_date
edit_certificate.certificate_expiry_date = expiry_date
edit_certificate.gov_certificate_id = form \
.gov_certificate_id.data
edit_certificate.status = form.status.data
edit_certificate.re_verify_status = form \
.re_verify_status.data
if edit_certificate.owner_farmer_id != \
form.owner_farmer_id.data:
edit_certificate.owner_farmer = models.Farmer \
.query.filter_by(
id=form.owner_farmer_id.data).one()
if edit_certificate.owner_group_id != \
form.owner_group_id.data:
edit_certificate.owner_group = models.Group.query \
.filter_by(id=form.owner_group_id.data).one()
flash(str(__('Update certificate success!')),
'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# add certificate
else:
form.id.data = str(uuid.uuid4())
if form.validate_on_submit():
start_date = form.certificate_start_date.data
expiry_date = form.certificate_expiry_date.data
if start_date > expiry_date:
form.certificate_expiry_date.errors.append(
__('The expiry date must greater than start date'))
flash((str(
__('The expiry date must greater '
'than start date!'))), 'error')
else:
owner_farmer = models.Farmer.query \
.filter_by(id=form.owner_farmer_id.data).one()
owner_group = models.Group.query \
.filter_by(id=form.owner_group_id.data).one()
new_cert = models.Certificate(
id=form.id.data,
certificate_code=form.certificate_code.data,
group_area=form.group_area.data,
member_count=form.member_count.data,
certificate_start_date=start_date,
certificate_expiry_date=expiry_date,
gov_certificate_id=form.gov_certificate_id.data,
status=form.status.data,
re_verify_status=form.re_verify_status.data,
owner_farmer=owner_farmer,
owner_group=owner_group)
sqla.session.add(new_cert)
sqla.session.commit()
flash(str(__('Add certificate success!')), 'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# form delete submit
if request.method == 'POST' and dform.data['submit_del']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
elif dform.validate_on_submit():
del_cert = sqla.session.query(models.Certificate) \
.filter_by(id=dform.id.data).one()
del_cert._deleted_at = func.now()
if dform.modify_info.data:
del_cert._modify_info = dform.modify_info.data
sqla.session.commit()
cs.remove(del_cert)
flash(str(__('Delete certificate success!')), 'success')
return redirect(url_for(request.endpoint))
return render_template('certificate/index.html',
cs=cs,
form=form,
dform=dform,
only_farmer=True)
def index():
form = AssociateGroupForm()
dform = DeleteForm()
if current_app.config['AJAX_CALL_ENABLED']:
form.province_id.choices = []
return render_template('agroup/index.html', form=form, dform=dform)
else:
province_id = current_user.province_id
if province_id and is_region_role():
ags = models.AssociateGroup.query.filter_by(
province_id=province_id, _deleted_at=None).order_by(
models.AssociateGroup.name.asc()).all()
form.province_id.choices = [
(p.province_id, p.type + " " + p.name) for p in
models.Province.query.filter_by(province_id=province_id).all()]
else:
ags = models.AssociateGroup.query.filter_by(_deleted_at=None)\
.order_by(models.AssociateGroup.name.asc()).all()
form.province_id.choices = []
# form create or edit submit
if request.method == 'POST' and form.data['submit']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
form.province_id.choices = [(form.province_id.data,
form.province_id.label.text)]
# edit associate group
if form.id.data:
if form.validate_on_submit():
edit_agroup = sqla.session.query(models.AssociateGroup) \
.filter_by(id=form.id.data).one()
edit_agroup.email = form.email.data
edit_agroup.associate_group_code = form \
.associate_group_code.data
edit_agroup.name = form.name.data
if edit_agroup.province_id != form.province_id.data:
edit_agroup.province = models.Province.query \
.filter_by(province_id=form.province_id.data) \
.one()
flash(str(__('Update associate group success!')),
'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# add associate group
else:
form.id.data = str(uuid.uuid4())
if form.validate_on_submit():
province = sqla.session.query(models.Province) \
.filter_by(province_id=form.province_id.data).one()
as_group = form.associate_group_code.data
new_agroup = models.AssociateGroup(
id=form.id.data,
associate_group_code=as_group,
name=form.name.data, province=province,
email=form.email.data,
)
sqla.session.add(new_agroup)
sqla.session.commit()
flash(str(__('Add associate group success!')), 'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# form delete submit
if request.method == 'POST' and dform.data['submit_del']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
elif dform.validate_on_submit():
del_agroup = sqla.session.query(models.AssociateGroup) \
.filter_by(id=dform.id.data).one()
del_agroup._deleted_at = func.now()
if dform.modify_info.data:
del_agroup._modify_info = dform.modify_info.data
sqla.session.commit()
flash(str(__('Delete associate group success!')), 'success')
return redirect(url_for(request.endpoint))
return render_template('agroup/index.html', ags=ags,
form=form, dform=dform)
def index():
form = GroupForm()
dform = DeleteForm()
if current_app.config['AJAX_CALL_ENABLED']:
form.associate_group_id.choices = []
form.ward_id.choices = []
form.district_id.choices = []
form.province_id.choices = []
associate_group_id = current_user.associate_group_id
if associate_group_id and is_region_role():
form.associate_group_id.choices = [
(ag.id, ag.name)
for ag in models.AssociateGroup.query.filter_by(
id=associate_group_id).all()
]
return render_template('group/index.html', form=form, dform=dform)
else:
province_id = current_user.province_id
if province_id and is_region_role():
gs = models.Group.query.filter_by(province_id=province_id,
_deleted_at=None).all()
form.associate_group_id.choices = [
(ag.id, ag.name)
for ag in models.AssociateGroup.query.filter_by(
province_id=province_id, _deleted_at=None).order_by(
models.AssociateGroup.name.asc()).all()
]
form.province_id.choices = [
(p.province_id, p.type + " " + p.name)
for p in models.Province.query.filter_by(
province_id=province_id).order_by(
models.Province.name.asc()).all()
]
form.district_id.choices = [
(d.district_id, d.type + " " + d.name)
for d in models.District.query.filter_by(
province_id=province_id).order_by(
models.District.name.asc()).all()
]
form.ward_id.choices = [
(w.ward_id, w.type + " " + w.name)
for w in models.Ward.query.join(models.District).filter(
models.District.province_id == province_id).order_by(
models.Ward.name.asc()).all()
]
else:
gs = models.Group.query.filter_by(_deleted_at=None).all()
form.associate_group_id.choices = []
form.province_id.choices = []
form.district_id.choices = []
form.ward_id.choices = []
# form create or edit submit
if request.method == 'POST' and form.data['submit']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
form.province_id.choices = [(form.province_id.data,
form.province_id.label.text)]
form.district_id.choices = [(form.district_id.data,
form.district_id.label.text)]
form.ward_id.choices = [(form.ward_id.data,
form.ward_id.label.text)]
form.associate_group_id.choices = [
(form.associate_group_id.data,
form.associate_group_id.label.text)
]
# edit group
if form.id.data:
if form.validate_on_submit():
edit_group = sqla.session.query(models.Group) \
.filter_by(id=form.id.data).one()
edit_group.group_code = form.group_code.data
edit_group.name = form.name.data
edit_group.village = form.village.data
if edit_group.associate_group_id != \
form.associate_group_id.data:
edit_group.associate_group = sqla.session \
.query(models.AssociateGroup) \
.filter_by(id=form.associate_group_id.data).one()
if edit_group.province_id != form.province_id.data:
edit_group.province = sqla.session \
.query(models.Province) \
.filter_by(province_id=form.province_id.data).one()
if edit_group.district_id != form.district_id.data:
edit_group.district = sqla.session \
.query(models.District) \
.filter_by(district_id=form.district_id.data).one()
if edit_group.ward_id != form.ward_id.data:
edit_group.ward = sqla.session.query(models.Ward) \
.filter_by(ward_id=form.ward_id.data).one()
sqla.session.commit()
for gr in gs:
if gr.id == edit_group.id:
gs.remove(gr)
gs.append(edit_group)
flash(str(__('Update group success!')), 'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# add group
else:
form.id.data = str(uuid.uuid4())
if form.validate_on_submit():
associate_group = sqla.session.query(
models.AssociateGroup) \
.filter_by(id=form.associate_group_id.data).one()
province = sqla.session.query(models.Province) \
.filter_by(province_id=form.province_id.data).one()
district = sqla.session.query(models.District) \
.filter_by(district_id=form.district_id.data).one()
ward = sqla.session.query(models.Ward) \
.filter_by(ward_id=form.ward_id.data).one()
new_group = models.Group(id=form.id.data,
group_code=form.group_code.data,
name=form.name.data,
village=form.village.data,
ward=ward,
district=district,
associate_group=associate_group,
province=province)
sqla.session.add(new_group)
sqla.session.commit()
gs.append(new_group)
flash(str(__('Add group success!')), 'success')
return redirect(url_for(request.endpoint))
else:
flash(str(__('The form is not validated!')), 'error')
# form delete submit
if request.method == 'POST' and dform.data['submit_del']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
elif dform.validate_on_submit():
del_group = sqla.session.query(models.Group) \
.filter_by(id=dform.id.data).one()
del_group._deleted_at = func.now()
if dform.modify_info.data:
del_group._modify_info = dform.modify_info.data
sqla.session.commit()
flash(str(__('Delete group success!')), 'success')
return redirect(url_for(request.endpoint))
return render_template('group/index.html',
gs=gs,
form=form,
dform=dform)
def index():
form = FarmerForm()
dform = DeleteForm()
if current_app.config['AJAX_CALL_ENABLED']:
form.group_id.choices = []
return render_template('farmer/index.html', form=form, dform=dform)
else:
province_id = current_user.province_id
if province_id and is_region_role():
farmers = models.Farmer.query.join(models.Group).filter(
models.Group.province_id == province_id,
models.Group._deleted_at == None,
models.Farmer._deleted_at == None).order_by(
models.Farmer.name.asc()).all()
form.group_id.choices = [
(p.id, p.name) for p in models.Group.query.filter_by(
province_id=province_id, _deleted_at=None).order_by(
models.Group.name.asc()).all()
]
else:
farmers = models.Farmer.query.filter_by(_deleted_at=None).all()
form.group_id.choices = []
form.group_id.choices = [(form.group_id.data, form.group_id.label.text)
]
# form create or edit submit
if request.method == 'POST' and form.data['submit']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
# edit user
if form.id.data:
if form.validate_on_submit():
edit_farmer = sqla.session.query(models.Farmer) \
.filter_by(id=form.id.data).one()
edit_farmer.farmer_code = form.farmer_code.data
edit_farmer.name = form.name.data
edit_farmer.gender = form.gender.data
edit_farmer.type = form.type.data
if edit_farmer.group_id != form.group_id.data:
new_group = models.Group.query.filter_by(
id=form.group_id.data).one()
edit_farmer.group = new_group
sqla.session.commit()
for fm in farmers:
if fm.id == edit_farmer.id:
farmers.remove(fm)
farmers.append(edit_farmer)
flash(str(__('Update farmer success!')), 'success')
# add user
else:
form.id.data = str(uuid.uuid4())
if form.validate_on_submit():
group_farmer = models.Group.query.filter_by(
id=form.group_id.data).one()
new_farmer = models.Farmer(
id=form.id.data,
type=form.type.data,
farmer_code=form.farmer_code.data,
name=form.name.data,
group=group_farmer,
gender=form.gender.data)
sqla.session.add(new_farmer)
sqla.session.commit()
farmers.append(new_farmer)
flash(str(__('Add farmer success!')), 'success')
return redirect(url_for(request.endpoint))
# form delete submit
if request.method == 'POST' and dform.data['submit_del']:
if not check_role(crud_role):
return redirect(url_for(request.endpoint))
elif dform.validate_on_submit():
del_farmer = sqla.session.query(models.Farmer) \
.filter_by(id=dform.id.data).one()
del_farmer._deleted_at = func.now()
if dform.modify_info.data:
del_farmer._modify_info = dform.modify_info.data
sqla.session.commit()
farmers.remove(del_farmer)
flash(str(__('Delete farmer success!')), 'success')
return redirect(url_for(request.endpoint))
return render_template('farmer/index.html',
farmers=farmers,
form=form,
dform=dform)
