class ActionOptCodesManager(BaseOptCodesManager):
CREATE_URL = Item.prepare_url('opt_codes/action/create')
UPDATE_URL = Item.prepare_url('opt_codes/action/update/%(optcode_id)s')
CREATE_FIELDS = {
'website':
lambda x: Item.sanitize_integer_value(x, 'website', blank=True),
'campaign':
lambda x: Item.sanitize_integer_value(x, 'campaign', blank=True),
'desc_mode':
lambda x: Item.sanitize_integer_value(x, 'desc_mode'),
'url':
lambda x: Item.sanitize_string_value(x, 'url'),
'method':
lambda x: Item.sanitize_integer_value(x, 'method'),
'action_type':
lambda x: Item.sanitize_integer_value(x, 'action_type'),
'status':
lambda x: Item.sanitize_integer_value(x, 'status'),
}
UPDATE_FIELDS = {
'desc_mode':
lambda x: Item.sanitize_integer_value(x, 'desc_mode', blank=True),
'url':
lambda x: Item.sanitize_string_value(x, 'url', blank=True),
'method':
lambda x: Item.sanitize_integer_value(x, 'method', blank=True),
'action_type':
lambda x: Item.sanitize_integer_value(x, 'action_type', blank=True),
'status':
lambda x: Item.sanitize_integer_value(x, 'status', blank=True),
}
def get(self, **kwargs):
"""
Args:
campaign (id)
website (id)
status (string)
start_date (date)
end_date (date)
appeal_id (string)
appeal_status (string)
limit (int)
offset (int)
"""
filtering = {
'filter_by': kwargs,
'available': {
'campaign': lambda x: Item.sanitize_integer_value(x, 'campaign', blank=True),
'website': lambda x: Item.sanitize_integer_value(x, 'website', blank=True),
'status': lambda x: Item.sanitize_string_value(x, 'status', blank=True),
'start_date': lambda x: Item.sanitize_string_value(x, 'start_date', blank=True),
'end_date': lambda x: Item.sanitize_string_value(x, 'end_date', blank=True),
'appeal_id': lambda x: Item.sanitize_string_value(x, 'appeal_id', blank=True),
'appeal_status': lambda x: Item.sanitize_string_value(x, 'appeal_status', blank=True),
}
}
return self.transport.get() \
.set_filtering(filtering) \
.set_pagination(**kwargs) \
.request(url=self.URL)
class TicketsManager(Item):
SCOPE = 'manage_tickets'
CREATE_URL = Item.prepare_url('tickets/create')
COMMENT_URL = Item.prepare_url('tickets/%(ticket_id)s/create')
CREATE_FIELDS = {
'subject': lambda x: Item.sanitize_string_value(x, 'subject'),
'text': lambda x: Item.sanitize_string_value(x, 'text'),
'campaign': lambda x: Item.sanitize_integer_value(x, 'campaign'),
'category': lambda x: Item.sanitize_integer_value(x, 'category'),
'priority': lambda x: Item.sanitize_integer_value(x, 'priority'),
}
COMMENT_FIELDS = {
'text': lambda x: Item.sanitize_string_value(x, 'text'),
}
def create(self, **kwargs):
"""
Args:
subject (str)
text (str)
campaign (int)
category (int)
priority (int)
"""
data = Item.sanitize_fields(self.CREATE_FIELDS, **kwargs)
return self.transport.post().set_data(data).request(url=self.CREATE_URL)
def comment(self, ticket_id, **kwargs):
"""
Args:
ticket_id (int)
text (str)
"""
request_data = {
'url': self.COMMENT_URL,
'ticket_id': Item.sanitize_id(ticket_id)
}
data = Item.sanitize_fields(self.COMMENT_FIELDS, **kwargs)
return self.transport.post().set_data(data).request(**request_data)
def get(self, **kwargs):
"""
Args:
campaign (list of int)
language (str)
order_by (str)
limit (int)
offset (int)
"""
ordering = {
'order_by': kwargs.get('order_by', None),
'available': self.ORDERING
}
filtering = {
'filter_by': kwargs,
'available': {
'campaign': lambda x: Item.sanitize_integer_array(x, 'campaign', True),
'language': lambda x: Item.sanitize_string_value(x, 'language', 2, 2, True),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_ordering(ordering) \
.set_filtering(filtering) \
.request(url=self.URL)
class DeeplinksManage(Item):
SCOPE = 'deeplink_generator'
CREATE_URL = Item.prepare_url(
'deeplink/%(website_id)s/advcampaign/%(campaign_id)s')
CREATE_FIELDS = {
'ulp': lambda x: Item.sanitize_string_array(x, 'ulp'),
'subid':
lambda x: Item.sanitize_string_value(x, 'subid', max_length=30),
# todo: subid[1-4]
}
def create(self, website_id, campaign_id, **kwargs):
"""
Args:
website_id (int)
campaign_id (int)
ulp (list of str)
subid (str)
"""
data = Item.sanitize_fields(self.CREATE_FIELDS, **kwargs)
request_data = {
'url': self.CREATE_URL,
'website_id': Item.sanitize_id(website_id),
'campaign_id': Item.sanitize_id(campaign_id),
}
return self.transport.get().set_data(data).request(**request_data)
def get(self, **kwargs):
"""
Args:
website (int)
has_tool (list of str)
limit (int)
offset (int)
language (str)
"""
filtering = {
'filter_by': kwargs,
'available': {
'website':
lambda x: Item.sanitize_integer_value(x, 'website', blank=True
),
'has_tool':
lambda x: Item.sanitize_string_array(x, 'has_tool', blank=True
),
'language':
lambda x: Item.sanitize_string_value(x, 'language', blank=True
),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
def get(self, **kwargs):
"""
Args:
website (list of int)
campaign (list of int)
search (str)
reason (int)
date_start (date)
date_end (date)
limit (int)
offset (int)
"""
filtering = {
'filter_by': kwargs,
'available': {
'website': lambda x: Item.sanitize_integer_array(x, 'website', blank=True),
'campaign': lambda x: Item.sanitize_integer_array(x, 'campaign', blank=True),
'search': lambda x: Item.sanitize_string_value(x, 'search', blank=True),
'reason': lambda x: Item.sanitize_integer_value(x, 'reason', blank=True),
'date_start': lambda x: Item.sanitize_date(x, 'date_start', blank=True),
'date_end': lambda x: Item.sanitize_date(x, 'date_end', blank=True),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
def get(self, _id, w_id, **kwargs):
"""
Here _id is an id of advertising campaign and
w_id is a id of website
Args:
_id (int)
w_id (int)
mobile_content (bool)
landing (int)
uri_scheme (str)
limit (int)
offset (int)
"""
request_data = {
'url': self.URL,
'campaign_id': Item.sanitize_id(_id),
'website_id': Item.sanitize_id(w_id)
}
filtering = {
'filter_by': kwargs,
'available': {
'mobile_content': lambda x: Item.sanitize_bool_value(x, blank=True),
'landing': lambda x: Item.sanitize_integer_value(x, 'landing', blank=True),
'uri_scheme': lambda x: Item.sanitize_string_value(x, 'uri_scheme', blank=True)
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(**request_data)
class CouponsBase(Item):
ORDERING = ('name', 'date_start', 'date_end', 'rating',)
FILTERING = {
'campaign': lambda x: Item.sanitize_integer_array(x, 'campaign', blank=True),
'campaign_category': lambda x: Item.sanitize_integer_array(x, 'campaign_category', blank=True),
'category': lambda x: Item.sanitize_integer_array(x, 'category', blank=True),
'type': lambda x: Item.sanitize_string_value(x, 'type', blank=True),
}
def getOne(self, code='ru'):
"""
Args:
code (str)
"""
request_data = {
'url': self.SINGLE_URL,
'code': Item.sanitize_string_value(code, 'code', 2, 2, False)
}
return self.transport.get().request(**request_data)
class LinksValidator(Item):
SCOPE = 'validate_links'
URL = Item.prepare_url('validate_links')
GET_FIELDS = {
'link': lambda x: Item.sanitize_string_value(x, 'link'),
}
def get(self, link, **kwargs):
"""
Args:
link (str)
"""
data = Item.sanitize_fields(self.GET_FIELDS, link=link)
return self.transport.get().set_data(data).request(url=self.URL)
def get(self, **kwargs):
"""
Args:
limit (int)
offset (int)
language (str)
"""
filtering = {
'filter_by': kwargs,
'available': {
'language': lambda x: Item.sanitize_string_value(x, 'language', 2, 2, True),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
def get(self, **kwargs):
"""
Args:
limit (int)
offset (int)
language (str)
"""
filtering = {
'filter_by': kwargs,
'available': {
'language':
lambda x: Item.sanitize_string_value(x, 'language', 2, 2, True
),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
def getOne(self, news_id, **kwargs):
"""
Args:
news_id (int)
language (str)
"""
request_data = {
'url': self.SINGLE_URL,
'news_id': self.sanitize_id(news_id)
}
filtering = {
'filter_by': kwargs,
'available': {
'language': lambda x: Item.sanitize_string_value(x, 'language', 2, 2, True),
}
}
return self.transport.get().set_filtering(filtering).request(**request_data)
def test_sanitize_fields(self):
fields = {
'field1': lambda x: Item.sanitize_non_blank_value(x, ''),
'field2': lambda x: Item.sanitize_integer_value(x, ''),
'field3': lambda x: Item.sanitize_string_value(x, '', blank=True),
}
data = Item.sanitize_fields(fields, field1='foobarbaz', field2=42, field3='')
self.assertDictEqual(data, {
'field1': 'foobarbaz',
'field2': 42,
'field3': ''
})
data = Item.sanitize_fields(fields, field1='foobarbaz', field2=42, field3='', field4='another')
self.assertDictEqual(data, {
'field1': 'foobarbaz',
'field2': 42,
'field3': ''
})
def getOne(self, _id, **kwargs):
"""
Args:
_id (int)
language (str)
"""
filtering = {
'filter_by': kwargs,
'available': {
'language':
lambda x: Item.sanitize_string_value(x, 'language', 2, 2, True
),
}
}
request_data = {
'url': self.SINGLE_URL,
'announcement_id': Item.sanitize_id(_id)
}
return self.transport.get().set_filtering(filtering).request(
**request_data)
def get(self, **kwargs):
"""
Args:
website (int)
has_tool (list of str)
limit (int)
offset (int)
language (str)
"""
filtering = {
'filter_by': kwargs,
'available': {
'website': lambda x: Item.sanitize_integer_value(x, 'website', blank=True),
'has_tool': lambda x: Item.sanitize_string_array(x, 'has_tool', blank=True),
'language': lambda x: Item.sanitize_string_value(x, 'language', blank=True),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
def get(self, **kwargs):
"""
Args:
website (list of int)
campaign (list of int)
search (str)
reason (int)
date_start (date)
date_end (date)
limit (int)
offset (int)
"""
filtering = {
'filter_by': kwargs,
'available': {
'website':
lambda x: Item.sanitize_integer_array(x, 'website', blank=True
),
'campaign':
lambda x: Item.sanitize_integer_array(
x, 'campaign', blank=True),
'search':
lambda x: Item.sanitize_string_value(x, 'search', blank=True),
'reason':
lambda x: Item.sanitize_integer_value(x, 'reason', blank=True),
'date_start':
lambda x: Item.sanitize_date(x, 'date_start', blank=True),
'date_end':
lambda x: Item.sanitize_date(x, 'date_end', blank=True),
}
}
return self.transport.get() \
.set_pagination(**kwargs) \
.set_filtering(filtering) \
.request(url=self.URL)
class LostOrdersManager(Item):
SCOPE = 'manage_lost_orders'
DELETE_URL = Item.prepare_url('lost_orders/%(lost_order_id)s/decline')
CREATE_URL = Item.prepare_url('lost_orders/create')
UPDATE_URL = Item.prepare_url('lost_orders/%(lost_order_id)s/update')
CREATE_FIELDS = {
'campaign': lambda x: Item.sanitize_integer_value(x, 'campaign'),
'website': lambda x: Item.sanitize_integer_value(x, 'website'),
'order_id': lambda x: Item.sanitize_string_value(x, 'order_id'),
'order_date': lambda x: Item.sanitize_date(x, 'order_date'),
'order_price': lambda x: Item.sanitize_float_value(x, 'order_price'),
'comment': lambda x: Item.sanitize_string_value(x, 'comment'),
'appeal_id': lambda x: Item.sanitize_string_value(x, 'appeal_id'),
}
def delete(self, lost_order_id):
"""
Args:
lost_order_id (int)
"""
request_data = {
'url': self.DELETE_URL,
'lost_order_id': Item.sanitize_id(lost_order_id),
}
return self.transport.delete().request(**request_data)
def create(self, attachments, **kwargs):
"""
Args:
attachments (list of str)
campaign (int)
website (int)
order_id (str)
order_date (date)
order_price (float)
appeal_id (str)
comment (str)
"""
data = Item.sanitize_fields(self.CREATE_FIELDS, **kwargs)
files = [('attachment', open(item, 'rb')) for item in Item.sanitize_string_array(attachments, 'attachments')]
return self.transport.post().set_data(data).set_files(files).request(url=self.CREATE_URL)
def update(self, lost_order_id, appeal_status):
"""
Args:
lost_order_id (int)
appeal_status (str)
"""
request_data = {
'url': self.UPDATE_URL,
'lost_order_id': Item.sanitize_id(lost_order_id),
}
data = {
'appeal_status': self.sanitize_string_value(appeal_status, 'appeal_status'),
}
return self.transport.put().set_data(data).request(**request_data)
class StatisticActions(StatisticBase):
"""
Statistics by actions
"""
SCOPE = 'statistics'
ORDERING = ('action', 'banner', 'banner_id', 'campaign', 'cart',
'click_date', 'conv_time', 'datetime', 'payment', 'status',
'subid', 'subid1', 'subid2', 'subid3', 'subid4', 'website')
FILTERING = {
'date_start':
lambda x: Item.sanitize_date(x, 'date_start', blank=True),
'date_end':
lambda x: Item.sanitize_date(x, 'date_end', blank=True),
'closing_date_start':
lambda x: Item.sanitize_date(x, 'closing_date_start', blank=True),
'closing_date_end':
lambda x: Item.sanitize_date(x, 'closing_date_end', blank=True),
'status_updated_start':
lambda x: Item.sanitize_long_date(
x, 'status_updated_start', blank=True),
'status_updated_end':
lambda x: Item.sanitize_long_date(x, 'status_updated_end', blank=True),
'website':
lambda x: Item.sanitize_integer_value(x, 'website', blank=True),
'campaign':
lambda x: Item.sanitize_integer_value(x, 'campaign', blank=True),
'subid':
lambda x: StatisticBase.check_sub_id(x),
'subid1':
lambda x: StatisticBase.check_sub_id(x),
'subid2':
lambda x: StatisticBase.check_sub_id(x),
'subid3':
lambda x: StatisticBase.check_sub_id(x),
'subid4':
lambda x: StatisticBase.check_sub_id(x),
'source':
lambda x: StatisticBase.check_sources(x),
'status':
lambda x: StatisticBase.check_status(x),
'keyword':
lambda x: Item.sanitize_string_value(x, 'keyword', blank=True),
'action':
lambda x: Item.sanitize_string_value(x, 'action', blank=True),
'action_type':
lambda x: StatisticBase.check_actions_type(x),
'action_id':
lambda x: Item.sanitize_integer_value(x, 'action_id', blank=True),
}
URL = Item.prepare_url('statistics/actions')
def get(self, **kwargs):
"""
Args:
date_start (date)
date_end (date)
closing_date_start (date)
closing_date_end (date)
status_updated_start (date)
status_updated_end (date)
website (int)
campaign (int)
subid (str)
subid1 (str)
subid2 (str)
subid3 (str)
subid4 (str)
source (str)
status (int)
keyword (str)
action (str)
action_type (str)
action_id (int)
limit (int)
offset (int)
order_by (list of int)
"""
return super(StatisticActions, self).get(self.URL, **kwargs)
class RetagManager(Item):
SCOPE = 'manage_webmaster_retag'
CREATE_URL = Item.prepare_url('retag/create')
UPDATE_URL = Item.prepare_url('retag/update/%(retag_id)s')
DELETE_URL = Item.prepare_url('retag/delete/%(retag_id)s')
CREATE_FIELDS = {
'website': lambda x: Item.sanitize_integer_value(x, 'website'),
'level': lambda x: Item.sanitize_integer_value(x, 'level'),
'active': lambda x: Item.sanitize_bool_integer_value(x, 'active', blank=True),
'script': lambda x: Item.sanitize_string_value(x, 'script'),
'comment': lambda x: Item.sanitize_string_value(x, 'comment', blank=True),
}
UPDATE_FIELDS = {
'level': lambda x: Item.sanitize_integer_value(x, 'level', blank=True),
'active': lambda x: Item.sanitize_bool_integer_value(x, 'active', blank=True),
'script': lambda x: Item.sanitize_string_value(x, 'script', blank=True),
'comment': lambda x: Item.sanitize_string_value(x, 'comment', blank=True),
}
def create(self, **kwargs):
"""
Args:
website (int)
level (int)
active (bool)
script (str)
comment (str)
"""
data = Item.sanitize_fields(self.CREATE_FIELDS, **kwargs)
return self.transport.post().set_data(data).request(url=self.CREATE_URL)
def update(self, retag_id, **kwargs):
"""
Args:
retag_id (int)
level (int)
active (bool)
script (str)
comment (str)
"""
request_data = {
'url': self.UPDATE_URL,
'retag_id': Item.sanitize_id(retag_id)
}
data = Item.sanitize_fields(self.UPDATE_FIELDS, **kwargs)
return self.transport.post().set_data(data).request(**request_data)
def delete(self, retag_id):
"""
Args:
retag_id (int)
"""
request_data = {
'url': self.DELETE_URL,
'retag_id': Item.sanitize_id(retag_id)
}
return self.transport.post().request(**request_data)
def test_sanitize_string_value(self):
self.assertEqual(Item.sanitize_string_value('foo', '', 10, None, False), 'foo')
self.assertEqual(Item.sanitize_string_value('foo', '', None, 2, False), 'foo')
self.assertEqual(Item.sanitize_string_value('foobarbaz', '', 10, 5, False), 'foobarbaz')
self.assertEqual(Item.sanitize_string_value('', '', None, None, True), '')
with self.assertRaises(ValueError):
Item.sanitize_string_value('', '', None, None, False)
Item.sanitize_string_value('foo', '', 2, None, False)
Item.sanitize_string_value('foo', '', None, 5, False)
Item.sanitize_string_value('foobarbaz', '', 5, 6, False)
class WebsitesManage(Item):
"""
Manage websites
"""
SCOPE = 'manage_websites'
CREATE_URL = Item.prepare_url('website/create')
UPDATE_URL = Item.prepare_url('website/update/%(website_id)s')
VERIFY_URL = Item.prepare_url('website/verify/%(website_id)s')
DELETE_URL = Item.prepare_url('website/delete/%(website_id)s')
CREATE_FIELDS = {
'name': lambda x: Item.sanitize_string_value(
x, 'name', max_length=200),
'kind': lambda x: Item.sanitize_string_value(
x, 'kind', max_length=20),
'language': lambda x: Item.sanitize_string_value(
x, 'language', max_length=2),
'adservice': lambda x: Item.sanitize_integer_value(
x, 'adservice', blank=True),
'site_url': lambda x: Item.sanitize_string_value(
x, 'site_url', max_length=255),
'description': lambda x: Item.sanitize_string_value(
x, 'description', max_length=20000, min_length=100),
'categories': lambda x: Item.sanitize_integer_array(
x, 'categories'),
'regions': lambda x: Item.sanitize_string_array(
x, 'regions', max_length=2),
'mailing_targeting': lambda x: Item.sanitize_bool_integer_value(
x, 'mailing_targeting', blank=True)
}
UPDATE_FIELDS = {
'name': lambda x: Item.sanitize_string_value(
x, 'name', max_length=200, blank=True),
'kind': lambda x: Item.sanitize_string_value(
x, 'kind', max_length=20, blank=True),
'language': lambda x: Item.sanitize_string_value(
x, 'language', max_length=2, blank=True),
'adservice': lambda x: Item.sanitize_integer_value(
x, 'adservice', blank=True),
'site_url': lambda x: Item.sanitize_string_value(
x, 'site_url', max_length=255, blank=True),
'description': lambda x: Item.sanitize_string_value(
x, 'description', max_length=20000, min_length=100, blank=True),
'categories': lambda x: Item.sanitize_integer_array(
x, 'categories', blank=True),
'regions': lambda x: Item.sanitize_string_array(
x, 'regions', max_length=2, blank=True),
'mailing_targeting': lambda x: Item.sanitize_bool_integer_value(
x, 'mailing_targeting', blank=True)
}
def create(self, **kwargs):
"""
Args:
name (str)
kind (str)
language (str)
adservice (int)
site_url (str)
description (str)
categories (list of int)
regions (list of str)
mailing_targeting (bool)
"""
data = Item.sanitize_fields(self.CREATE_FIELDS, **kwargs)
return self.transport.post().set_data(data).request(url=self.CREATE_URL)
def update(self, _id, **kwargs):
"""
Args:
_id (int)
name (str)
kind (str)
language (str)
adservice (int)
site_url (str)
description (str)
categories (list of int)
regions (list of str)
mailing_targeting (bool)
"""
data = Item.sanitize_fields(self.UPDATE_FIELDS, **kwargs)
request_data = {
'url': self.UPDATE_URL,
'website_id': Item.sanitize_id(_id)
}
return self.transport.post().set_data(data).request(**request_data)
def verify(self, _id):
"""
Args:
_id (int)
"""
request_data = {
'url': self.VERIFY_URL,
'website_id': Item.sanitize_id(_id)
}
return self.transport.post().request(**request_data)
def delete(self, _id):
"""
Args:
_id (int)
"""
request_data = {
'url': self.DELETE_URL,
'website_id': Item.sanitize_id(_id)
}
return self.transport.post().request(**request_data)
