def post(self, request, *args, **kwargs):
data = request.data
product_id = data.get('product_id')
origins = data.get('origins')
product = Products.objects.get(id=int(product_id))
product_origins = [org.country.code for org in product.origins]
for origin_code in origins:
if origin_code not in product_origins:
new_origin = ProductOrigin()
new_origin.product = product
new_origin.country = Country(code=origin_code)
new_origin.save()
else:
product_origins.remove(origin_code)
message = 'Product origins updated successfully.'
for origin_code in product_origins:
country = Country(code=origin_code)
delete_origin = ProductOrigin.objects.get(product=product,
country=country)
origin_items = delete_origin.origin_product_item.count()
if origin_items == 0:
delete_origin.delete()
else:
message = message + ' ' + str(
country.name
) + ' was not deleted as it has a product item.'
return Response({
'success': True,
'message': message
},
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
base_url = request.META.get(
'HTTP_HOST') if not settings.DEBUG else 'http://localhost:8000'
data = request.data
contact_us_from_website(base_url, data.get('name'), data.get('email'), \
data.get('subject'), data.get('comments'))
validated_error = validated_contact_us(data.get('name'), data.get('email'), \
data.get('subject'), data.get('comments'))
if validated_error is None:
send_email.delay('Contact Us', {'name': data.get('name')},
'Thanks for Contacting Doni & Company',
send_to_email=[data.get('email')])
send_email.delay('Contact Us Recieved', {
'name': data.get('name'),
'subject': data.get('subject'),
'email': data.get('email'),
'message': data.get('comments')
},
'[Website] %s contacted from Doni & Company' %
data.get('name'),
send_to_email=settings.EMAIL_INFO)
return Response(
{
'success': True,
'message': 'We have received your message.'
},
status=status.HTTP_200_OK)
else:
return validated_error
def get(self, request, *args, **kwargs):
user = request.user
business = Utilities.get_user_business(user)
q = request.GET.get('q')
if q == 'all' or q == 'drop_down':
if q == 'all':
locations = BpLocation.objects.filter(bp=business)
locations = [loc.get_obj() for loc in locations]
else:
locations = BpLocation.drop_down_obj(business)
print locations
return Response({'locations': locations}, status=status.HTTP_200_OK)
else:
location = BpLocation.objects.get(id=q)
location = location.get_obj()
return Response({'location': location}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
user = request.user
business = user.profile.business
all_business_ids = business.app_profile.all_associated_companies_id
total_warehouse = Warehouse.objects.count()
owned_warehouse = Warehouse.objects.filter(self_warehouse=True).count()
all_warehouses = Warehouse.objects.all()
all_warehouses = [
warehouse.dashboard_warehouse_card()
for warehouse in all_warehouses
]
all_warehouse_product = InventoryTransactionTruckFlow.get_product_report_for_all_warehouse(
)
own_warehouse_product = InventoryTransactionTruckFlow.get_product_report_for_all_warehouse(
own=True)
business_product_report = InventoryTransactionTruckFlow.get_all_warehouse_butsiness_product_report(
business_ids=all_business_ids)
return Response(
{
'data': {
'totalWarehouseCount': total_warehouse,
'ownedWarehouseCount': owned_warehouse,
'allWarehouse': all_warehouses,
'allWarehousesProduct': all_warehouse_product,
'ownWarehouseProduct': own_warehouse_product,
'businessProductReport': business_product_report
}
},
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
try:
user = request.user
business = user.profile.business
data = request.data
website = data.get('website')
business.bp_website = website
business.save()
return Response(
{
'success': True,
'message': 'Business details updated successfully!'
},
status=status.HTTP_200_OK)
except Exception, e:
return Response({'success': False, 'message': str(e)})
def post(self, request, *args, **kwargs):
local_trade_id = kwargs.get('file_id')
new_payment = LocalTradePayment()
return Response({
}, status=status.HTTP_200_OK)
def delete(self, request, *args, **kwargs):
try:
transaction_id = kwargs.get('tr_id')
note_id = kwargs.get('note_id')
note = TrNote.objects.filter(note_id=int(note_id)).filter(transaction__tr_id=int(transaction_id))
file_id = note[0].transaction.file_id
note.delete()
return Response({
'success':True,
'message': 'Trade Note for File Id %s deleted successfully.' % file_id
})
except Exception, e:
return Response({
'success': False,
'message': str(e)
})
def put(self, request, *args, **kwargs):
local_trade_id = kwargs.get('file_id')
payment_id = kwargs.get('payment_id')
return Response({
}, status=status.HTTP_200_OK)
class ManifestAPI(GenericAPIView):
permission_classes = (IsAuthenticated, )
def get(self, request, *args, **kwargs):
start_date = request.GET.get(u'startDate')
end_date = request.GET.get(u'endDate')
start_date = dateutil.parser.parse(str(start_date).replace('"', ''))
end_date = dateutil.parser.parse(str(end_date).replace('"', ''))
return Response(
{
'manifestItems':
ManifestItem.get_manifest_items(start_date, end_date)
},
status=status.HTTP_200_OK)
def delete(self, request, *args, **kwargs):
try:
manifest_id = kwargs.get('manifest_id')
manifest_item = ManifestItem.objects.get(id=manifest_id)
manifest_item.delete()
message = 'Manifest Item successfully deleted.'
success = True
except Exception, e:
success = False
message = str(e)
return Response(
{
'manifest_id': manifest_id,
'success': success,
'message': message
},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
product_item_id = request.GET.get('productItemId')
product_item = ProductItem.objects.get(id=product_item_id)
return Response({
'specification': product_item.get_specification(),
'success': True,
})
def save_product_item_price(self, data, user):
update_id = data.get('id')
product_item_id = data.get('productItemId')
price_market_id = data.get('priceMarketId')
price_metric_metric = data.get('priceMetricId')
price_time = data.get('priceTime')
comments = data.get('comments')
price_items = data.get('priceItems')
product_item = ProductItem.objects.get(id=product_item_id)
price_market = PriceMarket.objects.get(id=price_market_id)
price_metric = PriceMetric.objects.get(metric=price_metric_metric)
if update_id:
prod_price_item = ProductItemPrice.objects.get(id=update_id)
msg = self.messages['successPUT']
prod_price_item.update_by = user
prod_price_item.update_at = dt.now()
else:
prod_price_item = ProductItemPrice()
msg = self.messages['successPOST']
prod_price_item.created_by = user
prod_price_item.price_metric = price_metric
prod_price_item.comments = comments
prod_price_item.price_items = price_items
prod_price_item.product_item = product_item
prod_price_item.price_market = price_market
prod_price_item.price_time = dateutil.parser.parse(price_time)
prod_price_item.save()
return Response(
{
'success': True,
'message': msg,
'obj': prod_price_item.get_obj()
},
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
params = request.data
def error_response(error):
return Response({
'success': error,
'message': 'Incorrect Password'
}, status=status.HTTP_200_OK)
if request.user.is_authenticated():
print request.user
password = params.get('oldPassword')
user = authenticate(username=request.user.username,
password=password,
dashboard=True)
if not user:
return error_response('Incorrect Password')
new_password = params.get('newPassword')
confirm_password = params.get('confirmPassword')
print new_password, confirm_password
if new_password and new_password == confirm_password:
try:
user = User.objects.get(username=request.user.username)
user.set_password(new_password)
user.save()
return Response({
'success': True,
'message': 'User Password Changed successfully'
}, status=status.HTTP_200_OK)
except Exception, e:
return error_response(str(e))
def put(self, request, *args, **kwargs):
keyword_id = kwargs.get('id')
keyword_data = request.data
product_keyword = ProductKeyword.objects.get(id=keyword_id)
product_keyword.name = keyword_data.get('keyword')
product_keyword.save()
return Response(status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
user = request.user
business = user.profile.business
googe_analytics_connected = business.ga_token.exists()
if googe_analytics_connected:
ga_token = business.ga_token.all().order_by('-created')[0]
ga_token_data = json.loads(ga_token.data)
expiry = ga_token_data.get('token_expiry')
expiry_date = dateutil.parser.parse(expiry)
expiry_date = expiry_date.replace(tzinfo=pytz.UTC)
is_expired = (dt.now(pytz.utc) > expiry_date)
if is_expired:
ga_token.delete()
googe_analytics_connected = False
dashboard_data = dict()
dashboard_data['googleAnalyticsConnected'] = googe_analytics_connected
if googe_analytics_connected and not is_expired:
ga = GetGoogleAccessTokenAPI()
data = ga.get_data_from_google_analytics(business)
dashboard_data['data'] = data
return Response({
'success': True,
'dashboardData': dashboard_data
},
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
print request.data
start_date = request.data.get(u'startDate')
end_date = request.data.get(u'endDate')
currency_in = request.data.get(u'currencyIn')
currency_out = request.data.get(u'currencyOut')
start_date = dateutil.parser.parse(str(start_date).replace('"', ''))
end_date = dateutil.parser.parse(str(end_date).replace('"', ''))
start_date = start_date.date()
end_date = end_date.date()
graph_data = CurrencyExchange.objects.filter(currency_code_in=currency_in)\
.filter(currency_code_out=currency_out)\
.filter(exchange_rate_on__range=(start_date,end_date))
graph_data = [data.get_graph_obj() for data in graph_data]
return Response({
'data': {
'graphData': graph_data
},
'success': True
},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
type = request.GET.get('type')
page = request.GET.get('page')
user = request.user
all_business = self.get_all_business_drop_down(type, page, user.profile.business_id)
return Response({
'list': all_business
}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
port_id = kwargs.get('port_id')
port = ShippingPort.objects.get(id=port_id)
return Response({
'portObj': port.get_obj(),
'success': True
},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
all_warehouses = Warehouse.objects.filter(
business=request.user.profile.business)
all_warehouses = [
warehouse.get_warehouse_list_obj() for warehouse in all_warehouses
]
return Response({'list': all_warehouses}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
user = request.user
alpha = request.GET.get('alpha')
base_url = request.META.get('HTTP_HOST')
business = Utilities.get_user_business(user)
all_business = self.get_business_list(business, base_url, alpha)
return Response({'businessList': all_business},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
user = request.user
q = request.GET.get('q')
base_url = request.META.get('HTTP_HOST')
business = Utilities.get_user_business(user)
if q == self.ALL_QUERY or q == self.DROP_DOWN_QUERY:
all_users = UserProfile.objects.filter(business=business)
return Response(
{
'list':
[user.get_list_obj(request.user.id) for user in all_users]
},
status=status.HTTP_200_OK)
else:
profile = UserProfile.objects.get(user__id=int(q))
return Response({'user': profile.complete_profile(base_url)},
status=status.HTTP_200_OK)
def delete(self, request, *args, **kwargs):
data = request.data
id = data.get('id')
cat = ProductCategory.objects.get(id=id)
if cat.product_count == 0:
cat.delete()
return Response({
'success': True,
'message': 'Category successfully delete.'
})
else:
return Response({
'success':
False,
'message':
'Some Products are associated with these products, hence can not be deleted.'
})
def delete(self, request, *args, **kwargs):
try:
product_id = kwargs.get('product_id', None)
if product_id:
product_id = int(product_id)
product = Products.objects.get(id=product_id)
product.delete()
cache.delete('get_product_drop_down')
return Response(
{
'id': product_id,
'success': True,
'message': product.name + ' delete successfully.'
},
status=status.HTTP_200_OK)
except Exception, e:
return Response({'success': False, 'message': str(e)})
def get(self, request, *args, **kwargs):
query = request.GET.get('q')
pricing_market = PriceMarket.objects.all().order_by('origin')
pricing_market = [market.get_obj() for market in pricing_market]
return Response({'data': {
'pricingMarket': pricing_market
}},
status=status.HTTP_200_OK)
def save_manifest_item(self, data, user):
try:
data = data.get('manifestItem')
manifest_id = data.get('id')
metric = data.get('quantityMetricId')
manifest_date = dateutil.parser.parse(data.get('date'))
buyer_id = data.get('buyerId')
seller_id = data.get('sellerId')
product_id = data.get('productId')
quantity = data.get('quantity')
container_no = data.get('containerNo')
if int(buyer_id) == int(seller_id):
return Response(
{
'success': False,
'message': 'Buyer and Supplier can not be same'
},
status=status.HTTP_200_OK)
if manifest_id:
manifest_item = ManifestItem.objects.get(id=int(manifest_id))
manifest_item.updated_by = user
manifest_item.updated_at = dt.now()
message = 'Manifest item updated successfully'
else:
manifest_item = ManifestItem()
manifest_item.created_by = user
message = 'Manifest item created successfully'
manifest_item.date = manifest_date
manifest_item.quantity = quantity
manifest_item.quantity_metric = PriceMetric.objects.get(
metric=metric)
manifest_item.buyer = BpBasic.objects.get(bp_id=int(buyer_id))
manifest_item.seller = BpBasic.objects.get(bp_id=int(seller_id))
manifest_item.product = Products.objects.get(id=int(product_id))
manifest_item.container_no = container_no
manifest_item.save()
return Response(
{
'success': True,
'message': message,
'item': manifest_item.get_list_obj(),
},
status=status.HTTP_200_OK)
except Exception, e:
return Response({'success': False, 'message': str(e)})
def get(self, request, *args, **kwargs):
base_url = request.META.get('HTTP_HOST')
shipping_line = ShippingLine.objects.all()
shipping_line = [line.get_list_obj(base_url) for line in shipping_line]
return Response({
'list': shipping_line,
'success': True
},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
inventory_record_id = request.GET.get('id')
record = InventoryTransaction.objects.get(id=inventory_record_id)
return Response(
{
'success': True,
'recordObj': record.get_complete_obj()
},
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
for_pricing = request.GET.get('pricingOnWebsiteOnly', False)
for_pricing = str(for_pricing)
print for_pricing
product_items = ProductItem.objects.all().order_by('product_origin__product__name')
if for_pricing == 'true':
product_items = product_items.filter(price_on_website=True)
product_items = [product.get_dropdown() for product in product_items]
return Response({'list': product_items}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
product_id = request.GET.get('q')
if product_id != 'all':
product = Products.objects.get(id=product_id)
keywords = ProductKeyword.objects.filter(category=product.category)
else:
keywords = ProductKeyword.objects.all()
keywords = [key.get_obj() for key in keywords]
return Response({'list': keywords}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
country_code = request.GET.get('q')
from cities_light.models import Region
regions = Region.objects.filter(country__code2=country_code).order_by('name')
regions = [{
'id': region.name_ascii,
'name': region.name_ascii
} for region in regions]
return Response({'list': regions}, status=status.HTTP_200_OK)
def put(self, request, *args, **kwargs):
origin_id = kwargs.get('origin_id')
origin_data = request.data
user = request.user
origin = Origin.objects.get(id=origin_id)
origin.name = origin_data.get('name')
origin.updated_by = user
origin.save()
return Response(status=status.HTTP_200_OK)
