def test_reminder_message_is_not_created_if_member_has_pending_labaccess_days(
self):
member = self.db.create_member()
self.db.create_span(type=Span.LABACCESS,
enddate=self.date(LABACCESS_REMINDER_DAYS_BEFORE))
p0_count = 1
expected_sum = self.p0_price * p0_count
cart = [
{
"id": self.p0_id,
"count": p0_count
},
]
transaction = create_transaction(member_id=member.member_id,
purchase=dict(
cart=cart,
expected_sum=expected_sum),
stripe_reference_id="not_used")
transaction.status = Transaction.COMPLETED
db_session.add(transaction)
db_session.flush()
self.send_labaccess()
self.assertEqual(0, db_session.query(Message).count())
def answer_question(question_id):
data = request.json
option_id = int(data["option_id"])
option = db_session \
.query(QuizQuestionOption) \
.join(QuizQuestionOption.question) \
.filter((QuizQuestion.id == question_id) & (QuizQuestionOption.id == option_id) & (QuizQuestionOption.deleted_at == None)) \
.one_or_none()
if option == None:
return (
400,
f"Option id {option_id} is not an option for question id {question_id}"
)
db_session.add(
QuizAnswer(question_id=question_id,
option_id=option_id,
member_id=g.user_id,
correct=option.correct))
db_session.flush()
question = db_session.query(QuizQuestion).get(question_id)
json = quiz_question_entity.to_obj(question)
json["options"] = []
for option in question.options:
option = quiz_question_option_entity.to_obj(option)
json["options"].append(option)
return json
def complete_transaction(transaction):
assert transaction.status == Transaction.PENDING
transaction.status = Transaction.COMPLETED
db_session.add(transaction)
db_session.flush()
logger.info(f"completing transaction {transaction.id}, payment confirmed"
f", sending email receipt to member {transaction.member_id}")
send_receipt_email(transaction)
def create_product_action(self, **kwargs):
if self.product:
kwargs.setdefault('product_id', self.product.id)
obj = self.obj.create_product_action(**kwargs)
self.action = ProductAction(**obj)
db_session.add(self.action)
db_session.flush()
return self.action
def get_or_create(model, defaults=None, **kwargs):
entity = db_session.query(model).filter_by(**kwargs).first()
if entity:
return entity
entity = model(**{**kwargs, **defaults})
db_session.add(entity)
db_session.flush()
return entity
def create_product(self, **kwargs):
if self.category:
kwargs.setdefault('category_id', self.category.id)
obj = self.obj.create_product(**kwargs)
self.product = Product(**obj)
db_session.add(self.product)
db_session.flush()
return self.product
def request_password_reset(user_identification):
member = get_member_by_user_identification(user_identification)
token = generate_token()
db_session.add(PasswordResetToken(member_id=member.member_id, token=token))
db_session.flush()
send_message(
MessageTemplate.PASSWORD_RESET,
member,
url=config.get_admin_url(
f"/password-reset?reset_token={quote_plus(token)}"),
)
def _create_internal(self, data, commit=True):
""" Internal create to make it easier for subclasses to manipulated data before create. """
input_data = self.to_model(data)
self.validate_all(input_data)
if not input_data:
raise UnprocessableEntity("Can not create using empty data.")
entity = self.model(**input_data)
db_session.add(entity)
if commit:
db_session.commit()
else:
db_session.flush() # Flush to get id of created entity.
return entity
def add_membership_days(member_id=None,
span_type=None,
days=None,
creation_reason=None,
default_start_date=None):
assert days >= 0
old_span = db_session.query(Span).filter_by(
creation_reason=creation_reason).first()
if old_span:
if days == (old_span.enddate -
old_span.startdate).days and span_type == old_span.type:
# Duplicate add days can happend because the code that handles the transactions is not yet done in a db
# transaction, there are also an external script for handling puchases in ticktail that can create
# dupllicates.
return get_membership_summary(member_id)
raise UnprocessableEntity(f"Duplicate entry.",
fields='creation_reason',
what=NOT_UNIQUE)
if not default_start_date:
default_start_date = date.today()
last_end, = db_session.query(func.max(Span.enddate)).filter(
Span.member_id == member_id, Span.type == span_type,
Span.deleted_at.is_(None)).first()
if not last_end or last_end < default_start_date:
last_end = default_start_date
end = last_end + timedelta(days=days)
span = Span(member_id=member_id,
startdate=last_end,
enddate=end,
type=span_type,
creation_reason=creation_reason)
db_session.add(span)
db_session.flush()
return get_membership_summary(member_id)
def commit_transaction_to_db(member_id=None,
total_amount=None,
contents=None,
stripe_card_source_id=None,
activates_member=False):
""" Save as new transaction with transaction content in db and return it transaction. """
transaction = Transaction(member_id=member_id,
amount=total_amount,
status=Transaction.PENDING)
db_session.add(transaction)
db_session.flush()
for content in contents:
content.transaction_id = transaction.id
db_session.add(content)
db_session.flush()
db_session.execute(
"""
INSERT INTO webshop_transaction_actions (content_id, action_type, value, status)
SELECT :content_id AS content_id, action_type, SUM(:count * value) AS value, :pending AS status
FROM webshop_product_actions WHERE product_id=:product_id AND deleted_at IS NULL GROUP BY action_type
""", {
'content_id': content.id,
'count': content.count,
'pending': TransactionAction.PENDING,
'product_id': content.product_id
})
if activates_member:
# Mark this transaction as one that is for registering a member.
db_session.add(PendingRegistration(transaction_id=transaction.id))
db_session.add(
StripePending(transaction_id=transaction.id,
stripe_token=stripe_card_source_id))
return transaction
def box_terminator_validate(member_number=None,
box_label_id=None,
session_token=None):
query = get_box_query()
query = query.filter(Box.box_label_id == box_label_id)
try:
box = query.one()
except NoResultFound:
try:
member = db_session.query(Member).filter(
Member.member_number == member_number).one()
except NoResultFound:
raise NotFound()
box = Box(member_id=member.member_id, box_label_id=box_label_id)
box.last_check_at = datetime.utcnow()
box.session_token = session_token
db_session.add(box)
db_session.flush()
return get_box_info(box)
def activate_member(member):
logger.info(f"activating member {member.member_id}")
member.deleted_at = None
db_session.add(member)
db_session.flush()
send_new_member_email(member)
def complete_pending_action(action):
action.status = TransactionAction.COMPLETED
action.completed_at = datetime.utcnow()
db_session.add(action)
db_session.flush()
def delete_product(self, id=None):
product_id = id or self.product.id
db_session.query(ProductAction).filter(ProductAction.product_id == product_id).delete()
db_session.query(Product).filter(Product.id == product_id).delete()
db_session.flush()
def delete_category(self, id=None):
category_id = id or self.category.id
db_session.query(ProductCategory).filter(ProductCategory.id == category_id).delete()
db_session.flush()
