def get_content(name):
from splice.environment import Environment
env = Environment.instance()
row = env.db.session.query(Content).filter(Content.name == name).first()
c = row_to_dict(row) if row else None
if c is not None:
versions = []
for version in row.versions:
versions.append(row_to_dict(version))
c['versions'] = versions
return c
def get_content(name):
from splice.environment import Environment
env = Environment.instance()
row = env.db.session.query(Content).filter(Content.name == name).first()
c = row_to_dict(row) if row else None
if c is not None:
versions = []
for version in row.versions:
versions.append(row_to_dict(version))
c['versions'] = versions
return c
def insert_content(session, record):
record = record.copy()
versions = record.pop('versions', [])
vns = [Version(**version) for version in versions]
content = Content(versions=vns, **record)
session.add(content)
session.flush()
c = row_to_dict(content)
vs = []
for version in content.versions:
vs.append(row_to_dict(version))
c['versions'] = vs
return c
def insert_content(session, record):
record = record.copy()
versions = record.pop('versions', [])
vns = [Version(**version) for version in versions]
content = Content(versions=vns, **record)
session.add(content)
session.flush()
c = row_to_dict(content)
vs = []
for version in content.versions:
vs.append(row_to_dict(version))
c['versions'] = vs
return c
def get_campaigns(account_id=None, past=True, in_flight=True, scheduled=True, utctoday=None):
from splice.environment import Environment
env = Environment.instance()
query = env.db.session.query(Campaign)
if account_id is not None:
query = query.filter(Campaign.account_id == account_id)
if utctoday is None:
utctoday = datetime.utcnow().date()
rows = query.order_by(Campaign.id.desc()).all()
campaigns = []
for row in rows:
ret = row_to_dict(row)
countries = []
for country in row.countries:
countries.append(country.country_code)
ret['countries'] = countries
# filter based on start and end dates unless an account ID is specified
if ((past and row.end_date.date() <= utctoday) or
(in_flight and row.end_date.date() >= utctoday >= row.start_date.date()) or
(scheduled and row.start_date.date() >= utctoday)):
campaigns.append(ret)
return campaigns
def get_tile(id):
from splice.environment import Environment
env = Environment.instance()
row = (env.db.session.query(Tile).get(id))
return row_to_dict(row) if row else None
def get_campaigns(account_id=None,
past=True,
in_flight=True,
scheduled=True,
utctoday=None):
from splice.environment import Environment
env = Environment.instance()
query = env.db.session.query(Campaign)
if account_id is not None:
query = query.filter(Campaign.account_id == account_id)
if utctoday is None:
utctoday = datetime.utcnow().date()
rows = query.order_by(Campaign.id.desc()).all()
campaigns = []
for row in rows:
ret = row_to_dict(row)
countries = []
for country in row.countries:
countries.append(country.country_code)
ret['countries'] = countries
# filter based on start and end dates unless an account ID is specified
if ((past and row.end_date.date() <= utctoday) or
(in_flight
and row.end_date.date() >= utctoday >= row.start_date.date())
or (scheduled and row.start_date.date() >= utctoday)):
campaigns.append(ret)
return campaigns
def get_contents():
from splice.environment import Environment
env = Environment.instance()
rows = (env.db.session.query(Content).order_by(Content.id.desc()).all())
output = []
for d in rows:
versions = []
for version in d.versions:
versions.append(row_to_dict(version))
c = row_to_dict(d)
c['versions'] = versions
output.append(c)
return output
def update_account(session, account_id, record):
account = session.query(Account).get(account_id)
if account is None:
raise NoResultFound('Account not found')
for key, val in record.items():
setattr(account, key, val)
return row_to_dict(account)
def update_content(session, content_id, record):
content = session.query(Content).get(content_id)
if content is None: # pragma: no cover
raise NoResultFound('Content not found')
for key, val in record.items():
setattr(content, key, val)
return row_to_dict(content)
def get_accounts():
from splice.environment import Environment
env = Environment.instance()
rows = (env.db.session.query(Account).order_by(Account.id.desc()).all())
output = [row_to_dict(d) for d in rows]
return output
def update_account(session, account_id, record):
account = session.query(Account).get(account_id)
if account is None:
raise NoResultFound('Account not found')
for key, val in record.items():
setattr(account, key, val)
return row_to_dict(account)
def update_content(session, content_id, record):
content = session.query(Content).get(content_id)
if content is None: # pragma: no cover
raise NoResultFound('Content not found')
for key, val in record.items():
setattr(content, key, val)
return row_to_dict(content)
def insert_version(session, content_id, record):
content = session.query(Content).get(content_id)
if content is None: # pragma: no cover
raise NoResultFound('Content not found')
version = Version(**record)
content.versions.append(version)
session.flush()
return row_to_dict(version)
def get_account(id):
from splice.environment import Environment
env = Environment.instance()
row = (
env.db.session
.query(Account).get(id)
)
return row_to_dict(row) if row else None
def insert_version(session, content_id, record):
content = session.query(Content).get(content_id)
if content is None: # pragma: no cover
raise NoResultFound('Content not found')
version = Version(**record)
content.versions.append(version)
session.flush()
return row_to_dict(version)
def insert_tile(session, record):
if not tile_exists(session, record["title"], record["target_url"],
record["image_uri"], record["enhanced_image_uri"],
record["type"], record["adgroup_id"]):
tile = Tile(**record)
session.add(tile)
session.flush()
return row_to_dict(tile)
else:
raise InvalidRequestError("Tile already exists")
def insert_campaign(session, record):
record = record.copy()
countries = record.pop('countries')
countries_objs = [CampaignCountry(country_code=country) for country in countries]
campaign = Campaign(countries=countries_objs, **record)
session.add(campaign)
session.flush()
new = row_to_dict(campaign)
new["countries"] = countries
return new
def update_tile(session, tile_id, record):
""" Tile is immutable once it gets created, the only field could be updated
is the status.
"""
tile = session.query(Tile).get(tile_id)
if tile is None:
raise NoResultFound("No result found")
for key, val in record.items():
setattr(tile, key, val)
return row_to_dict(tile)
def update_version(session, content_id, version, record):
version = (session.query(Version).filter(
Version.content_id == content_id).filter(
Version.version == version).first())
if version is None: # pragma: no cover
raise NoResultFound('Version not found')
record["last_updated"] = datetime.datetime.utcnow()
for key, val in record.items():
setattr(version, key, val)
return row_to_dict(version)
def get_contents():
from splice.environment import Environment
env = Environment.instance()
rows = (
env.db.session
.query(Content)
.order_by(Content.id.desc())
.all()
)
output = []
for d in rows:
versions = []
for version in d.versions:
versions.append(row_to_dict(version))
c = row_to_dict(d)
c['versions'] = versions
output.append(c)
return output
def insert_campaign(session, record):
record = record.copy()
countries = record.pop('countries')
countries_objs = [
CampaignCountry(country_code=country) for country in countries
]
campaign = Campaign(countries=countries_objs, **record)
session.add(campaign)
session.flush()
new = row_to_dict(campaign)
new["countries"] = countries
return new
def get_accounts():
from splice.environment import Environment
env = Environment.instance()
rows = (
env.db.session
.query(Account)
.order_by(Account.id.desc())
.all()
)
output = [row_to_dict(d) for d in rows]
return output
def get_campaign(campaign_id):
from splice.environment import Environment
env = Environment.instance()
row = (env.db.session.query(Campaign).get(campaign_id))
if row:
ret = row_to_dict(row)
countries = []
for country in row.countries:
countries.append(country.country_code)
ret['countries'] = countries
return ret
else:
return None
def get_adgroup(id):
from splice.environment import Environment
env = Environment.instance()
row = (env.db.session.query(Adgroup).get(id))
if row is None:
return None
new = row_to_dict(row)
categories = []
for category in row.categories:
categories.append(category.category)
new['categories'] = categories
return new
def update_version(session, content_id, version, record):
version = (
session
.query(Version)
.filter(Version.content_id == content_id)
.filter(Version.version == version)
.first()
)
if version is None: # pragma: no cover
raise NoResultFound('Version not found')
record["last_updated"] = datetime.datetime.utcnow()
for key, val in record.items():
setattr(version, key, val)
return row_to_dict(version)
def insert_adgroup(session, record):
if not adgroup_exists(session, record["name"], record["type"], record["campaign_id"]):
record = record.copy()
categories = record.pop('categories', [])
if record['type'] == "suggested" and not categories:
raise InvalidRequestError("Each suggested adgroup must have at least one category.")
cats = [AdgroupCategory(category=category) for category in categories]
adgroup = Adgroup(categories=cats, **record)
session.add(adgroup)
session.flush()
new = row_to_dict(adgroup)
# row_to_dict can't handle nested objects
new['categories'] = categories
return new
else:
raise InvalidRequestError("Adgroup already exists")
def get_campaign(campaign_id):
from splice.environment import Environment
env = Environment.instance()
row = (
env.db.session
.query(Campaign).get(campaign_id)
)
if row:
ret = row_to_dict(row)
countries = []
for country in row.countries:
countries.append(country.country_code)
ret['countries'] = countries
return ret
else:
return None
def get_adgroups_by_campaign_id(campaign_id):
from splice.environment import Environment
env = Environment.instance()
rows = (env.db.session.query(Adgroup).filter(
Adgroup.campaign_id == campaign_id).order_by(Adgroup.id.desc()).all())
output = []
for d in rows:
new = row_to_dict(d)
categories = []
for category in d.categories:
categories.append(category.category)
new['categories'] = categories
output.append(new)
return output
def get_adgroup(id):
from splice.environment import Environment
env = Environment.instance()
row = (
env.db.session
.query(Adgroup).get(id)
)
if row is None:
return None
new = row_to_dict(row)
categories = []
for category in row.categories:
categories.append(category.category)
new['categories'] = categories
return new
def insert_adgroup(session, record):
if not adgroup_exists(session, record["name"], record["type"],
record["campaign_id"]):
record = record.copy()
categories = record.pop('categories', [])
if record['type'] == "suggested" and not categories:
raise InvalidRequestError(
"Each suggested adgroup must have at least one category.")
cats = [AdgroupCategory(category=category) for category in categories]
adgroup = Adgroup(categories=cats, **record)
session.add(adgroup)
session.flush()
new = row_to_dict(adgroup)
# row_to_dict can't handle nested objects
new['categories'] = categories
return new
else:
raise InvalidRequestError("Adgroup already exists")
def update_adgroup(session, adgroup_id, record):
adgroup = session.query(Adgroup).get(adgroup_id)
if adgroup is None:
raise NoResultFound("No result found")
if "paused" in record:
adgroup.paused = record["paused"]
is_unique_key_changed = False
if "name" in record and adgroup.name != record["name"]:
is_unique_key_changed = True
adgroup.name = record["name"]
if "type" in record and adgroup.type != record["type"]:
is_unique_key_changed = True
adgroup.type = record["type"]
if is_unique_key_changed and adgroup_exists(
session, adgroup.name, adgroup.type, adgroup.campaign_id):
raise InvalidRequestError("Adgroup already exists")
if "frequencey_cap_daily" in record:
adgroup.frequency_cap_daily = record["frequency_cap_daily"]
if "frequencey_cap_total" in record:
adgroup.frequency_cap_total = record["frequency_cap_total"]
session.flush()
new = row_to_dict(adgroup)
if "categories" in record:
if adgroup.type == "suggested" and not record['categories']:
raise InvalidRequestError(
"Each suggested adgroup must have at least one category")
for category in adgroup.categories:
session.delete(category)
for category in record['categories']:
adgroup.categories.append(AdgroupCategory(category=category))
new['categories'] = record['categories']
return new
def update_campaign(session, campaign_id, record):
campaign = session.query(Campaign).get(campaign_id)
if campaign is None:
raise NoResultFound('Campaign not found')
record = record.copy()
countries = record.pop("countries", [])
for key, val in record.items():
setattr(campaign, key, val)
session.flush()
new = row_to_dict(campaign)
if countries:
for country in campaign.countries:
session.delete(country)
for country in countries:
campaign.countries.append(CampaignCountry(country_code=country))
new['countries'] = countries
return new
def update_adgroup(session, adgroup_id, record):
adgroup = session.query(Adgroup).get(adgroup_id)
if adgroup is None:
raise NoResultFound("No result found")
if "paused" in record:
adgroup.paused = record["paused"]
is_unique_key_changed = False
if "name" in record and adgroup.name != record["name"]:
is_unique_key_changed = True
adgroup.name = record["name"]
if "type" in record and adgroup.type != record["type"]:
is_unique_key_changed = True
adgroup.type = record["type"]
if is_unique_key_changed and adgroup_exists(session, adgroup.name, adgroup.type, adgroup.campaign_id):
raise InvalidRequestError("Adgroup already exists")
if "frequencey_cap_daily" in record:
adgroup.frequency_cap_daily = record["frequency_cap_daily"]
if "frequencey_cap_total" in record:
adgroup.frequency_cap_total = record["frequency_cap_total"]
session.flush()
new = row_to_dict(adgroup)
if "categories" in record:
if adgroup.type == "suggested" and not record['categories']:
raise InvalidRequestError("Each suggested adgroup must have at least one category")
for category in adgroup.categories:
session.delete(category)
for category in record['categories']:
adgroup.categories.append(AdgroupCategory(category=category))
new['categories'] = record['categories']
return new
def update_campaign(session, campaign_id, record):
campaign = session.query(Campaign).get(campaign_id)
if campaign is None:
raise NoResultFound('Campaign not found')
record = record.copy()
countries = record.pop("countries", [])
for key, val in record.items():
setattr(campaign, key, val)
session.flush()
new = row_to_dict(campaign)
if countries:
for country in campaign.countries:
session.delete(country)
for country in countries:
campaign.countries.append(CampaignCountry(country_code=country))
new['countries'] = countries
return new
def get_adgroups_by_campaign_id(campaign_id):
from splice.environment import Environment
env = Environment.instance()
rows = (
env.db.session
.query(Adgroup)
.filter(Adgroup.campaign_id == campaign_id)
.order_by(Adgroup.id.desc())
.all()
)
output = []
for d in rows:
new = row_to_dict(d)
categories = []
for category in d.categories:
categories.append(category.category)
new['categories'] = categories
output.append(new)
return output
def insert_account(session, record):
account = Account(**record)
session.add(account)
session.flush()
return row_to_dict(account)
def insert_account(session, record):
account = Account(**record)
session.add(account)
session.flush()
return row_to_dict(account)
