def set_selectable_pacts(self):
"""User can select pacts bound to specific resource and available to him.
Limit pact to the logged user. Do not see pacts from other GAS than mine.
Due to "Supplier" resources that was showing pact for another GAS.
This method set form attribute self._pacts
"""
resource_pacts = self.request.resource.pacts
if self.request.user.is_superuser:
self._pacts = resource_pacts
else:
self._pacts = GASSupplierSolidalPact.objects.none()
user_pacts = self.request.user.person.pacts.values_list('pk')
#KO by fero unneeded code: "if resource_pacts and user_pacts and "
if resource_pacts.count() and user_pacts.count():
self._pacts = resource_pacts.filter(pk__in = user_pacts)
if not self._pacts.count():
log.error("Cannot add an order on a resource with no pacts")
self._messages['error'].append(ug("No pacts selectable for you. Please contact staff"))
else:
self._messages['info'].append(ug("Please select the pact you want to make an order for"))
def __unicode__(self):
return ug("%s %s - %s by %s") % (
self.object,
self.content_type,
self.content_date.strftime("%d/%m/%Y %H:%M"),
self.user
)
class Block(AbstractBlock):
BLOCK_NAME = "balance"
BLOCK_VALID_RESOURCE_TYPES = ["site", "gas", "supplier", "pact", "gasmember"]
BLOCK_DESCRIPTION = ug("Balance")
def _get_user_actions(self, request):
#COMMENT BY fero: no need for these actions now
return []
user_actions = []
gas_list = self.resource.gas_list
for gas in gas_list:
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Balance state"),
popup_form=False,
),
]
break
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id, args)
res = self.resource
user_actions = self._get_user_actions(request)
if args == "INCOME":
if request.method == 'POST':
form = BalanceForm(request, request.POST)
if form.is_valid():
with transaction.commit_on_success():
if form.cleaned_data:
form.save()
# return self.response_success()
# else:
# return self.response_error(form.errors)
else:
form = BalanceForm(request)
# if args == "":
ctx = {
'resource' : res,
'sanet_urn' : "%s/%s" % (resource_type, resource_id),
'form' : BalanceForm(request),
'user_actions' : user_actions,
}
return render_to_xml_response('blocks/balance.xml', ctx)
def clean(self):
cleaned_data = self.cleaned_data
dt_start = cleaned_data.get("datetime_start")
e_end = self.cleaned_data.get('empty_end')
e_del = self.cleaned_data.get('empty_delivery')
if e_end:
del cleaned_data["datetime_end"]
del cleaned_data["delivery_datetime"]
elif e_del:
del cleaned_data["delivery_datetime"]
dt_end = cleaned_data.get("datetime_end")
dt_delivery = cleaned_data.get("delivery_datetime")
#log.debug("BaseOrderForm compare date [%s<%s<%s]" % (dt_start, dt_end, dt_delivery))
# Only do something if both fields are valid so far.
if dt_start and dt_end:
if dt_start >= dt_end:
raise forms.ValidationError(ug(u"Start date can't be later or equal than end date"))
if dt_end and dt_delivery:
if dt_end > dt_delivery:
raise forms.ValidationError(ug("End date can't be later than delivery date"))
# Set cleaned data additional keys:
# pact: needed if we are in EditOrderForm
pact = cleaned_data.get('pact') or self.instance.pact
cleaned_data['pact'] = pact
# delivery_appointment: d would be saved within save()
if dt_delivery:
d = self.get_delivery()
cleaned_data['delivery_appointment'] = d
# withdrawal_appointment
# COMMENT fero: I think that EVERY order SHOULD have withdrawal_place
# COMMENT fero: ok to not show in form, but programmatically create it anyway
# see also...
# https://github.com/feroda/gasistafelice/commit/1209d5390c1a354d24cf8c53add98fbef4b0a55a#commitcomment-935905
if pact.gas.config.use_withdrawal_place:
if self.cleaned_data.get('withdrawal_datetime'):
w = self.get_withdrawal()
cleaned_data['withdrawal_appointment'] = w
# Always return the full collection of cleaned data.
return cleaned_data
def authenticate_credentials(self, key) -> Tuple[User, str]:
user = token_cache.get_user(token=key)
if user is None:
msg = 'Wrong authentication token or your session has expired. Please login.'
logger.error(msg)
raise exceptions.AuthenticationFailed(ug(msg))
_, token = token_cache.update(user)
return user, token
class Block(AbstractBlock):
BLOCK_NAME = "order_insolute"
BLOCK_VALID_RESOURCE_TYPES = ["order"]
BLOCK_DESCRIPTION = ug("Insolute management")
# def __init__(self):
# super(Block, self).__init__()
# self.description = ug("Insolute management")
def _get_user_actions(self, request):
user_actions = []
order = self.resource.order
if request.user.has_perm(CASH,
obj=ObjectWithContext(self.resource.gas)):
if order.is_closed() or order.is_unpaid():
user_actions += [
ResourceBlockAction(
block_name=self.BLOCK_NAME,
resource=self.resource,
name=INCOME,
verbose_name=ug("Insolute payment"),
popup_form=False,
),
]
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id,
args)
res = self.resource
if args == "INCOME":
if request.method == 'POST':
form = InsoluteOrderForm(request, request.POST)
if form.is_valid():
with transaction.commit_on_success():
if form.cleaned_data:
try:
form.save()
# return self.response_success()
# return HttpResponse(_("Insolute saved"))
except Exception, e:
msg = ug(
"Transaction Insolute ERROR: ") + e.message
form._errors["amount"] = form.error_class(
[msg])
else:
def set_initial_referrer(self):
"""Set initial value for 'referrer_person'. """
ref_field = self.fields['referrer_person']
if self.request.user.person in ref_field.queryset:
# Person is the current user: referrers
ref_field.initial = self.request.user.person
elif ref_field.queryset.count() > 0:
ref_field.initial = ref_field.queryset[0]
else:
self._messages['error'].append(ug("No referrers selectable for you. Please add tech referrer to add pact referrers for your GAS"))
class Block(AbstractBlock):
BLOCK_NAME = "balance_gm"
BLOCK_VALID_RESOURCE_TYPES = ["gasmember"]
BLOCK_DESCRIPTION = ug("Balance")
def _get_user_actions(self, request):
user_actions = []
gas_list = self.resource.gas_list
for gas in gas_list:
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
user_actions += [
ResourceBlockAction(
block_name=self.BLOCK_NAME,
resource=self.resource,
name=INCOME,
verbose_name=ug("Account transaction"),
popup_form=False,
),
]
break
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id,
args)
res = self.resource
gas = res.gas
extra_html = ""
if args == "INCOME":
if request.method == 'POST':
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
form = TransationGMForm(request, request.POST)
if form.is_valid():
with transaction.commit_on_success():
if form.cleaned_data:
try:
form.save()
except Exception, e:
msg = ug("Transaction gasmember ERROR: "
) + e.message
form._errors["amount"] = form.error_class(
[msg])
else:
def _get_user_actions(self, request):
user_actions = []
gas_list = self.resource.gas_list
for gas in gas_list:
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Account transaction"),
popup_form=False,
),
]
break
return user_actions
def _get_user_actions(self, request):
user_actions = []
gas_list = self.resource.gas_list
for gas in gas_list:
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Account transaction"),
popup_form=False,
),
]
break
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id, args)
res = self.resource
gas = res.gas
extra_html = ""
if args == "INCOME":
if request.method == 'POST':
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
form = TransationGMForm(request, request.POST)
if form.is_valid():
with transaction.commit_on_success():
if form.cleaned_data:
try:
form.save()
except Exception, e:
msg = ug("Transaction gasmember ERROR: ") + e.message
form._errors["amount"] = form.error_class([msg])
def _get_user_actions(self, request):
user_actions = []
order = self.resource.order
if request.user.has_perm(CASH, obj=ObjectWithContext(self.resource.gas)):
if order.is_closed() or order.is_unpaid():
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Insolute payment"),
popup_form=False,
),
]
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id, args)
res = self.resource
gas = res.gas
extra_html = ""
if args == "INCOME":
if request.method == 'POST':
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
form = TransationGMForm(request, request.POST)
if form.is_valid():
with transaction.atomic():
if form.cleaned_data:
try:
form.save()
except Exception, e:
msg = ug("Transaction gasmember ERROR: ") + e.message
form._errors["amount"] = form.error_class([msg])
def _get_user_actions(self, request):
user_actions = []
order = self.resource.order
if request.user.has_perm(CASH, obj=ObjectWithContext(self.resource.gas)):
if order.is_closed() or order.is_unpaid():
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Insolute payment"),
popup_form=False,
),
]
return user_actions
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id, args)
res = self.resource
if args == "INCOME":
if request.method == 'POST':
form = InsoluteOrderForm(request, request.POST)
if form.is_valid():
with transaction.commit_on_success():
if form.cleaned_data:
try:
form.save()
# return self.response_success()
# return HttpResponse(_("Insolute saved"))
except Exception, e:
msg = ug("Transaction Insolute ERROR: ") + e.message
form._errors["amount"] = form.error_class([msg])
def get_response(self, request, resource_type, resource_id, args):
super(Block, self).get_response(request, resource_type, resource_id, args)
res = self.resource
if args == "INCOME":
if request.method == 'POST':
form = InsoluteOrderForm(request, request.POST)
if form.is_valid():
with transaction.atomic():
if form.cleaned_data:
try:
form.save()
# return self.response_success()
# return HttpResponse(_("Insolute saved"))
except Exception, e:
msg = ug("Transaction Insolute ERROR: ") + e.message
form._errors["amount"] = form.error_class([msg])
def _get_user_actions(self, request):
#COMMENT BY fero: no need for these actions now
return []
user_actions = []
gas_list = self.resource.gas_list
for gas in gas_list:
if request.user.has_perm(CASH, obj=ObjectWithContext(gas)):
user_actions += [
ResourceBlockAction(
block_name = self.BLOCK_NAME,
resource = self.resource,
name=INCOME, verbose_name=ug("Balance state"),
popup_form=False,
),
]
break
return user_actions
def __init__(self, *args, **kw):
super(AddPlannedOrderForm, self).__init__(*args, **kw)
self._messages['info'].append(
ug("If you want you can plan your orders with some frequency until a specific date"
))
def __str__(self):
msg = '{0} : {1}'.format(ug("Can't find a unique value for field(s)"),
', '.join(self.fields))
return msg
def __str__(self):
msg = '{0} : {1}'.format(
ug("Can't find a unique value for field(s)"),
', '.join(self.fields)
)
return msg
def clean(self):
"""Validate data here. Not in save().
Here we do not have self.instance, but we have self.cleaned_data
Validate order planning at these conditions:
* if repeat_order is set:
* [DEPRECATED] datetime_end must be set
* repeat_until_date must be set
* repeat_until_date must be > datetime_start + _repeat_frequency
"""
cleaned_data = super(AddPlannedOrderForm, self).clean()
self.is_repeated = cleaned_data['repeat_order']
if self.is_repeated:
_repeat_frequency = cleaned_data['repeat_frequency']
_repeat_items = None
_repeat_until_date = cleaned_data['repeat_until_date']
#Domthu: 20120318 can be unknow datetime, see Fero-Orlando directive.
# if not cleaned_data.get('datetime_end'):
# raise forms.ValidationError(ug("To plan an order you must set an end date and time"))
#NOTE fero: I do not completely agree.
#NOTE fero: You can leave an order open for 3 month, but plan it every 1 month,
#NOTE fero: don't you agree?
#NOTE fero: otherwise this stuff is buggy and should add the condition that
#NOTE fero: (datetime_end - datetime_start).days < _repeat_frequency
#WAS # Calcul _repeat_items
#WAS: # Calcul _repeat_items
#WAS: tmp_date = self.instance.datetime_end.date()
#WAS: log.debug("repeat params: start %s end %s(%s), until: %s desired: %s" % (
#WAS: self.instance.datetime_start,
#WAS: self.instance.datetime_end,
#WAS: tmp_date,
#WAS: _repeat_until_date,
#WAS: _repeat_frequency
#WAS: ))
#WAS: if _repeat_until_date and tmp_date and _repeat_until_date > tmp_date:
if not _repeat_until_date:
raise forms.ValidationError(ug("To plan an order you must set an end planning date"))
start_date = cleaned_data['datetime_start'].date()
min_repeat_until_date = start_date + timedelta(days=_repeat_frequency)
if _repeat_until_date < min_repeat_until_date:
raise forms.ValidationError(ug("To plan an order you must set an end planning date later than start date + frequency"))
#NOTE fero: just be positive and do not rely on self.instance:
#WAS: tmp_date = self.instance.datetime_start.date()
#WAS: tmp_days = (_repeat_until_date - tmp_date).days
#WAS: log.debug("repeat tmp date: %s days: %s" % (tmp_date, tmp_days))
#WAS: _repeat_items = tmp_days // _repeat_frequency
#WAS: log.debug("repeat parameters: %s, items: %s" % (_repeat_frequency, _repeat_items))
how_many_days = (_repeat_until_date - start_date).days
_repeat_items = how_many_days // _repeat_frequency
log.debug("repeat tmp date: %s days: %s" % (start_date, how_many_days))
log.debug("repeat parameters: %s, items: %s" % (_repeat_frequency, _repeat_items))
# Verify params request is consistent
if not _repeat_frequency or not _repeat_items or _repeat_items < 1:
log.debug("CREATE REPEATED ORDERS: repeat some parameter wrong" +
"_repeat_frequency=%s, _repeat_items=%s" % (
_repeat_frequency, _repeat_items
))
raise forms.ValidationError(ug("Something wrong has happened with planning parameters"))
self._repeat_items = _repeat_items
self._repeat_frequency = _repeat_frequency
return cleaned_data
def __init__(self, *args, **kw):
super(AddPlannedOrderForm, self).__init__(*args, **kw)
self._messages['info'].append(ug("If you want you can plan your orders with some frequency until a specific date"))
def clean(self):
"""Validate data here. Not in save().
Here we do not have self.instance, but we have self.cleaned_data
Validate order planning at these conditions:
* if repeat_order is set:
* [DEPRECATED] datetime_end must be set
* repeat_until_date must be set
* repeat_until_date must be > datetime_start + _repeat_frequency
"""
cleaned_data = super(AddPlannedOrderForm, self).clean()
self.is_planning_order = cleaned_data['repeat_order']
if self.is_planning_order:
_repeat_frequency = cleaned_data['repeat_frequency']
_repeat_items = None
_repeat_until_date = cleaned_data['repeat_until_date']
#Domthu: 20120318 can be unknow datetime, see Fero-Orlando directive.
# if not cleaned_data.get('datetime_end'):
# raise forms.ValidationError(ug("To plan an order you must set an end date and time"))
#NOTE fero: I do not completely agree.
#NOTE fero: You can leave an order open for 3 month, but plan it every 1 month,
#NOTE fero: don't you agree?
#NOTE fero: otherwise this stuff is buggy and should add the condition that
#NOTE fero: (datetime_end - datetime_start).days < _repeat_frequency
#WAS # Calcul _repeat_items
#WAS: # Calcul _repeat_items
#WAS: tmp_date = self.instance.datetime_end.date()
#WAS: log.debug("repeat params: start %s end %s(%s), until: %s desired: %s" % (
#WAS: self.instance.datetime_start,
#WAS: self.instance.datetime_end,
#WAS: tmp_date,
#WAS: _repeat_until_date,
#WAS: _repeat_frequency
#WAS: ))
#WAS: if _repeat_until_date and tmp_date and _repeat_until_date > tmp_date:
if not _repeat_until_date:
raise forms.ValidationError(
ug("To plan an order you must set an end planning date"))
start_date = cleaned_data['datetime_start'].date()
min_repeat_until_date = start_date + timedelta(
days=_repeat_frequency)
if _repeat_until_date < min_repeat_until_date:
raise forms.ValidationError(
ug("To plan an order you must set an end planning date later than start date + frequency"
))
#NOTE fero: just be positive and do not rely on self.instance:
#WAS: tmp_date = self.instance.datetime_start.date()
#WAS: tmp_days = (_repeat_until_date - tmp_date).days
#WAS: log.debug("repeat tmp date: %s days: %s" % (tmp_date, tmp_days))
#WAS: _repeat_items = tmp_days // _repeat_frequency
#WAS: log.debug("repeat parameters: %s, items: %s" % (_repeat_frequency, _repeat_items))
how_many_days = (_repeat_until_date - start_date).days
_repeat_items = how_many_days // _repeat_frequency
log.debug(
"plan info: start_date=%s days=%s, repeat_until_date=%s" %
( ` start_date `, how_many_days, ` _repeat_until_date `))
log.debug(
"plan info2: frequency=%s, items=%s, min_repeat_until_date=%s"
%
(_repeat_frequency, _repeat_items, ` min_repeat_until_date `))
# Verify params request is consistent
if not _repeat_frequency or not _repeat_items or _repeat_items < 1:
log.debug(
"CREATE PLANNED ORDERS: repeat some parameter wrong" +
"_repeat_frequency=%s, _repeat_items=%s" %
(_repeat_frequency, _repeat_items))
raise forms.ValidationError(
ug("Something wrong has happened with planning parameters")
)
self._repeat_items = _repeat_items
self._repeat_frequency = _repeat_frequency
return cleaned_data
