def mutate(self, info, **kwargs):
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
order_id = kwargs.get('order_id')
order = get_model_object(Order, 'id', order_id)
invoice_document = kwargs.get('invoice_file')
validate_empty_field('Invoice file', invoice_document)
invoice_exist = \
Invoice.objects.filter(order_id=order_id).exists()
if invoice_exist:
raise GraphQLError(
ORDERS_ERROR_RESPONSES["duplicate_upload_error"])
# check if order belongs to an outlet
if order.destination_outlet_id != outlet.id:
raise GraphQLError(
ORDERS_ERROR_RESPONSES["initiation_invoice_upload_error"])
image_url = cloudinary.uploader.upload(invoice_document).get('url')
invoice = Invoice(order_id=order.id,
outlet_id=outlet.id,
image_url=image_url)
with SaveContextManager(invoice) as invoice:
return UploadInvoice(
invoice=invoice,
message=SUCCESS_RESPONSES["upload_success"].format("Invoice"))
def resolve_stock_transfers(self, info):
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
stock_transfers = StockTransfer.objects.filter(
Q(destination_outlet=outlet) | Q(sending_outlet=outlet))
if not stock_transfers:
raise GraphQLError(STOCK_ERROR_RESPONSES["zero_stock_transfers"])
return stock_transfers
def mutate(self, info, **kwargs):
user = info.context.user
destination_outlet = check_user_has_an_active_outlet(user)
transfer = StockTransfer.objects.filter(
id=kwargs['transfer_number'],
destination_outlet=destination_outlet).first()
if not transfer:
raise GraphQLError(STOCK_ERROR_RESPONSES["close_transfer_error"])
transfer.complete_status = False
transfer.save()
success = STOCK_SUCCESS_RESPONSES["stock_transfer_close_success"]
return CloseStockTransfer(success=success)
def resolve_autosuggest_product_order(self, info, **kwargs):
"""
Auto suggest products that needs to be ordered and the
quantity that needs to be ordered for based on the sales
velocity calculator
Returns:
list: tuple(product_name, quantity)
"""
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
product_to_order = autosuggest_product_order(outlet=outlet)
return product_to_order
def resolve_stock_transfer(self, info, **kwargs):
"""Method to retrieve a single stock transfer using its number
"""
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
validate.validate_transfer(kwargs['transfer_number'])
stock_transfer = get_model_object(
StockTransfer, 'id', kwargs['transfer_number'])
sending_outlet = stock_transfer.sending_outlet
destination_outlet = stock_transfer.destination_outlet
if stock_transfer and (str(sending_outlet) == str(outlet)
or str(destination_outlet) == str(outlet)):
return stock_transfer
raise GraphQLError(STOCK_ERROR_RESPONSES["inexistent_stock_transfer"])
def resolve_events(self, info, **kwargs):
page_count = kwargs.get('page_count')
page_number = kwargs.get('page_number')
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
events_set = Event.objects.filter(Q(user=user)
| Q(outlet=outlet)).order_by('id')
if page_count or page_number:
events = pagination_query(events_set, page_count, page_number)
Query.pagination_result = events
return events[0]
if events_set:
paginated_response = pagination_query(
events_set, PAGINATION_DEFAULT["page_count"],
PAGINATION_DEFAULT["page_number"])
Query.pagination_result = paginated_response
return paginated_response[0]
return GraphQLError(EVENTS_ERROR_RESPONSES["no_events_error"])
def mutate(self, info, **kwargs):
user = info.context.user
validate.validate_fields(**kwargs)
product_id = kwargs['product_id']
batch_ids = kwargs['batch_ids']
quantities = kwargs['quantities']
product = get_model_object(Product, 'id', product_id)
sending_outlet = check_user_has_an_active_outlet(user)
destination_outlet = get_model_object(Outlet, 'id',
kwargs['destination_outlet_id'])
if str(sending_outlet) == str(destination_outlet):
raise GraphQLError(
STOCK_ERROR_RESPONSES["outlet_transfer_validation"])
product_batch_ids = product.batch_info.values_list("id", flat=True)
message = "Batch with ids {} do not exist in this product"
check_validity_of_ids(batch_ids, product_batch_ids, message=message)
product_batch_quantities = [
product.batch_info.get(id=id).quantity for id in batch_ids
]
check_validity_of_quantity(quantities, product_batch_quantities,
batch_ids)
stock_transfer = StockTransfer(product=product,
sending_outlet=sending_outlet,
destination_outlet=destination_outlet)
with SaveContextManager(stock_transfer) as stock_transfer:
for index, value in enumerate(batch_ids):
stock_transfer_record = StockTransferRecord.objects.create(
quantity=quantities[index], batch_id=value)
stock_transfer.stock_transfer_record.add(stock_transfer_record)
success = [STOCK_SUCCESS_RESPONSES["stock_transfer_open_success"]]
return OpenStockTransfer(stock_transfer=stock_transfer,
success=success)
def mutate(self, info, **kwargs):
user = info.context.user
outlet = check_user_has_an_active_outlet(user)
event_type = kwargs.get('event_type')
event_type_id = kwargs.get('event_type_id')
event_type = get_model_object(EventTypeModel, 'id', event_type_id)
ValidateAdmin().validate_master_admin(user, event_type.name)
event = Event(
event_type_id=kwargs.get('event_type_id'),
start_date=kwargs.get('start_date', datetime.today().date()),
end_date=kwargs.get('end_date'),
start_time=kwargs.get(
'start_time', datetime.now().time().strftime("%H:%M:%S")),
end_time=kwargs.get('end_time'),
event_title=kwargs.get('event_title'),
description=kwargs.get('description')
)
with SaveContextManager(event) as event:
event.user.add(user)
event.outlet.add(outlet)
event.save()
success = SUCCESS_RESPONSES["creation_success"].format("Event")
return CreateEvent(event=event, success=success)
