class ContiModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'test_db'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
con_name = db.Column(db.Unicode(255))
lname = db.Column(db.Unicode(80))
sa.orm.configure_mappers()
def __init__(self, con_name, lname):
self.con_name = con_name
self.lname = lname
def json(self):
return {'id': self.id, 'name': self.con_name, 'Login_Name': self.lname}
@classmethod
def find_by_name(cls, con_name):
return cls.query.filter_by(con_name=con_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class UserLevelModel(db.Model,VersioningMixin):
__versioned__ = {}
__tablename__ = 'userlevel'
userlevel_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
level_name = db.Column(db.Unicode(255))
user_type_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self,level_name,user_type_id):
self.level_name = level_name
self.user_type_id = user_type_id
def json(self):
return{
'id':self.userlevel_id,
'name':self.level_name,
'token':self.token
}
@classmethod
def find_by_id(cls, userlevel_id):
return cls.query.filter_by(userlevel_id=userlevel_id).first()
@classmethod
def find_by_name(cls,level_name):
return cls.query.filter_by(level_name=level_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self) :
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
schema = {'level_name': {'required': True, 'empty': False, 'type': 'string'},
'user_type_id': {'required': True, 'empty': False, 'type': 'integer'}}
v = Validator(schema)
v.allow_unknown = True
return True if(v.validate(data)) else v.errors
class ServiceModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'service'
service_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
service_name = db.Column(db.Unicode(255))
logo = db.Column(db.Unicode(255))
brand_id = db.Column(db.Integer, db.ForeignKey('brands.brand_id'))
category_id = db.Column(db.Integer,
db.ForeignKey('brandcategory.category_id'))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
brands = db.relationship('BrandsModel')
brandcategory = db.relationship('BrandCategoryModel')
sa.orm.configure_mappers()
def __init__(self, service_name, logo, brand_id, category_id):
self.service_name = service_name
self.logo = logo
self.brand_id = brand_id
self.category_id = category_id
def json(self):
return {
'id': self.service_id,
'name': self.service_name,
'logo': self.logo
}
@classmethod
def find_by_name(cls, service_name):
return cls.query.filter_by(service_name=service_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Product(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(256), default="")
quantity = db.Column(db.Integer, default=0)
cost = db.Column(db.Float, default=0)
price = db.Column(db.Float, default=0)
class TargetAudienceProfileModel(db.Model,VersioningMixin):
__versioned__ = {}
__tablename__ = 'target_audience_profile'
target_audience_profile_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
audience_profile_name = db.Column(db.Unicode(255))
business = db.Column(db.Unicode(255))
age_group_id = db.Column(db.Integer, db.ForeignKey('age_group.age_group_id'))
gender_id = db.Column(db.Integer, db.ForeignKey('gender.gender_id'))
target_languages = db.Column(db.Unicode(255))
target_nationality = db.Column(db.Unicode(255))
target_education = db.Column(db.Unicode(255))
target_occupation = db.Column(db.Unicode(255))
target_interest = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
agegroup = db.relationship('AgeGroupModel')
gender = db.relationship('GenderModel')
sa.orm.configure_mappers()
def __init__(self,audience_profile_name,business,age_group_id,gender_id,target_languages,target_nationality,target_education,target_occupation,target_interest):
self.audience_profile_name = audience_profile_name
self.business = business
self.age_group_id = age_group_id
self.gender_id = gender_id
self.target_languages = target_languages
self.target_nationality = target_nationality
self.target_education = target_education
self.target_occupation = target_occupation
self.target_interest = target_interest
def json(self):
return{
'id':self.target_audience_profile_id,
'name':self.audience_profile_name,
}
@classmethod
def find_by_name(cls,audience_profile_name):
return cls.query.filter_by(audience_profile_name=audience_profile_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self) :
db.session.add(self)
db.session.commit()
class UserPermissionModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'userpermissions'
permission_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
section_name = db.Column(db.Unicode(255))
feature_name = db.Column(db.Unicode(255))
user_type_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self, section_name, feature_name, user_type_id):
self.section_name = section_name
self.feature_name = feature_name
self.user_type_id = user_type_id
def json(self):
return {
'id': self.permission_id,
'name': self.section_name,
'feature_name': self.feature_name
}
@classmethod
def find_by_name(cls, section_name):
return cls.query.filter_by(section_name=section_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class BrandCategoryModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'brandcategory'
category_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
category_name = db.Column(db.Unicode(255))
logo = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self, category_name, logo):
self.category_name = category_name
self.logo = logo
def json(self):
return {
'id': self.category_id,
'name': self.category_name,
}
@classmethod
def find_by_name(cls, category_name):
return cls.query.filter_by(category_name=category_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Currency(db.Model):
__tablename__ = 'currency'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(length=50), unique=True, nullable=False)
@classmethod
async def get_or_create(cls, name: str) -> 'Currency':
get_query = cls.query.where(cls.name == name)
result = await get_query.gino.first()
if not result:
try:
result = await cls.create(name=name)
except asyncpg.UniqueViolationError:
result = await get_query.gino.first()
return result
class BrandsModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'brands'
brand_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
brand_name = db.Column(db.Unicode(255))
user_id = db.Column(db.Integer)
industry_id = db.Column(db.Integer, db.ForeignKey('industry.industry_id'))
brand_category_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
industry = db.relationship('IndustryModel')
sa.orm.configure_mappers()
def __init__(self, brand_name, user_id, industry_id, brand_category_id):
self.brand_name = brand_name
self.user_id = user_id
self.industry_id = industry_id
self.brand_category_id = brand_category_id
def json(self):
return {'id': self.brand_id, 'name': self.brand_name}
@classmethod
def find_by_name(cls, brand_name):
return cls.query.filter_by(brand_name=brand_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class AgeGroupModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'age_group'
age_group_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
age_group = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self, age_group):
self.age_group = age_group
def json(self):
return {
'id': self.age_group_id,
'name': self.age_group,
}
@classmethod
def find_by_name(cls, age_group):
return cls.query.filter_by(age_group=age_group).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class UsersModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.Unicode(255))
password = db.Column(db.Unicode(55))
user_type_id = db.Column(db.Integer)
company_name = db.Column(db.Unicode(255))
first_name = db.Column(db.Unicode(55))
last_name = db.Column(db.Unicode(55))
phone = db.Column(db.Unicode(10))
title = db.Column(db.Unicode(255))
owner_manager = db.Column(db.Unicode(255))
yearly_budget = db.Column(db.Integer)
logo = db.Column(db.Unicode(255))
city = db.Column(db.Unicode(255))
country_id = db.Column(db.Integer)
address = db.Column(db.Unicode(255))
timezone = db.Column(db.Unicode(255))
level = db.Column(db.Unicode(255))
permission = db.Column(db.Unicode(255))
assigned_brands = db.Column(db.Unicode(255))
assigned_products = db.Column(db.Unicode(255))
assigned_services = db.Column(db.Unicode(255))
parent_user_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self, email, password, user_type_id, company_name, first_name,
last_name, phone, title, owner_manager, yearly_budget, logo,
city, country_id, address, timezone, level, permission,
assigned_brands, assigned_products, assigned_services,
parent_user_id):
self.email = email
self.password = password
self.user_type_id = user_type_id
self.company_name = company_name
self.first_name = first_name
self.last_name = last_name
self.phone = phone
self.title = title
self.owner_manager = owner_manager
self.yearly_budget = yearly_budget
self.logo = logo
self.city = city
self.country_id = country_id
self.address = address
self.timezone = timezone
self.level = level
self.permission = permission
self.assigned_brands = assigned_brands
self.assigned_products = assigned_products
self.assigned_services = assigned_services
self.parent_user_id = parent_user_id
def json(self):
return {'id': self.user_id, 'name': self.email}
@classmethod
def find_by_Email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class UsersModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'users'
UserID = db.Column(db.Integer, primary_key=True, autoincrement=True)
UserTypeID = db.Column(db.Integer)
CompanyName = db.Column(db.Unicode(255))
Email = db.Column(db.Unicode(255))
Password = db.Column(db.Unicode(55))
FirstName = db.Column(db.Unicode(55))
LastName = db.Column(db.Unicode(55))
Phone = db.Column(db.Unicode(10))
Title = db.Column(db.Unicode(255))
OwnerManager = db.Column(db.Unicode(255))
YearlyBudget = db.Column(db.Integer)
Logo = db.Column(db.Unicode(255))
City = db.Column(db.Unicode(255))
CountryID = db.Column(db.Integer)
Address = db.Column(db.Unicode(255))
Timezone = db.Column(db.Unicode(255))
Level = db.Column(db.Unicode(255))
Permission = db.Column(db.Unicode(255))
AssignedBrands = db.Column(db.Unicode(255))
AssignedProducts = db.Column(db.Unicode(255))
AssignedServices = db.Column(db.Unicode(255))
ParentUserId = db.Column(db.Integer)
CreatedBy = db.Column(db.Integer, default=u'NULL')
CreatedOn = db.Column(db.DateTime, server_default=db.func.now())
ModifiedBy = db.Column(db.Integer, default=u'NULL')
ModifiedOn = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
DeletedBy = db.Column(db.Integer, default=u'NULL')
DeletedOn = db.Column(db.DateTime, server_default=db.func.now())
sa.orm.configure_mappers()
def __init__(self, UserTypeID, CompanyName, Email, Password, FirstName,
LastName, Phone, Title, OwnerManager, YearlyBudget, Logo,
City, CountryID, Address, Timezone, Level, Permission,
AssignedBrands, AssignedProducts, AssignedServices,
ParentUserId, CreatedBy, CreatedOn, ModifiedBy, ModifiedOn,
DeletedBy, DeletedOn):
self.UserTypeID = UserTypeID
self.CompanyName = CompanyName
self.Email = Email
self.Password = Password
self.FirstName = FirstName
self.LastName = LastName
self.Phone = Phone
self.Title = Title
self.OwnerManager = OwnerManager
self.YearlyBudget = YearlyBudget
self.Logo = Logo
self.City = City
self.CountryID = CountryID
self.Address = Address
self.Timezone = Timezone
self.Level = Level
self.Permission = Permission
self.AssignedBrands = AssignedBrands
self.AssignedProducts = AssignedProducts
self.AssignedServices = AssignedServices
self.ParentUserId = ParentUserId
self.CreatedBy = CreatedBy
self.CreatedOn = datetime.utcnow()
self.ModifiedBy = ModifiedBy
self.ModifiedOn = datetime.utcnow()
self.DeletedBy = DeletedBy
self.DeletedOn = datetime.utcnow()
def json(self):
return {'id': self.IndustryID, 'name': self.IndustryName}
@classmethod
def find_by_Email(cls, Email):
return cls.query.filter_by(Email=Email).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class ServiceModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'service'
service_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
service_name = db.Column(db.Unicode(255))
logo = db.Column(db.Unicode(255))
brand_id = db.Column(db.Integer, db.ForeignKey('brands.brand_id'))
category_id = db.Column(db.Integer,
db.ForeignKey('brandcategory.category_id'))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
brands = db.relationship('BrandsModel')
brandcategory = db.relationship('BrandCategoryModel')
sa.orm.configure_mappers()
def __init__(self, service_name, logo, brand_id, category_id):
self.service_name = service_name
self.logo = logo
self.brand_id = brand_id
self.category_id = category_id
def json(self):
return {
'id': self.service_id,
'name': self.service_name,
'logo': self.logo,
'token': self.token
}
@classmethod
def find_by_id(cls, service_id):
return cls.query.filter_by(service_id=service_id).first()
@classmethod
def find_by_name(cls, service_name):
return cls.query.filter_by(service_name=service_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
schema = {
'service_name': {
'required': True,
'empty': False,
'type': 'string'
},
'logo': {
'required': True,
'empty': False,
'type': 'string'
},
'brand_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'category_id': {
'required': True,
'empty': False,
'type': 'integer'
}
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
class AgeGroupModel(db.Model,VersioningMixin):
__versioned__ = {}
__tablename__ = 'age_group'
age_group_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
age_group = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self,age_group):
self.age_group = age_group
def json(self):
return{
'id':self.age_group_id,
'name':self.age_group,
'token':self.token
}
@classmethod
def find_by_id(cls, age_group_id):
return cls.query.filter_by(age_group_id=age_group_id).first()
@classmethod
def find_by_name(cls,age_group):
return cls.query.filter_by(age_group=age_group).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self) :
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
if _request.method == "POST":
schema = {'age_group': {'required': True, 'empty': False, 'type': 'string'}}
else :
schema = {'age_group': {'required': True, 'empty': False, 'type': 'string'}}
v = Validator(schema)
v.allow_unknown = True
return True if(v.validate(data)) else v.errors
class CampaignModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'campaign'
campaign_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
campaign_name = db.Column(db.Unicode(255))
description = db.Column(db.Unicode(255))
brand_id = db.Column(db.Integer, db.ForeignKey('brands.brand_id'))
product_ids = db.Column(db.Unicode(255))
currency_id = db.Column(db.Integer)
budget_amount = db.Column(db.Integer)
objective_id = db.Column(db.Integer)
kpi_id = db.Column(db.Integer)
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
days = db.Column(db.Integer)
target_locations = db.Column(db.Unicode(255))
exclude_locations = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
barnd = db.relationship('BrandsModel')
sa.orm.configure_mappers()
def __init__(self, campaign_name, description, brand_id, product_ids,
currency_id, budget_amount, objective_id, kpi_id,
target_locations, exclude_locations):
self.campaign_name = campaign_name
self.description = description
self.brand_id = brand_id
self.product_ids = product_ids
self.currency_id = currency_id
self.budget_amount = budget_amount
self.objective_id = objective_id
self.kpi_id = kpi_id
self.target_locations = target_locations
self.exclude_locations = exclude_locations
def json(self):
return {
'id': self.campaign_id,
'name': self.campaign_name,
}
@classmethod
def find_by_name(cls, campaign_name):
return cls.query.filter_by(campaign_name=campaign_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class TargetAudienceProfileModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'target_audience_profile'
target_audience_profile_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
token = db.Column(db.Unicode(80))
audience_profile_name = db.Column(db.Unicode(255))
business = db.Column(db.Unicode(255))
age_group_id = db.Column(db.Integer,
db.ForeignKey('age_group.age_group_id'))
gender_id = db.Column(db.Integer, db.ForeignKey('gender.gender_id'))
target_languages = db.Column(db.Unicode(255))
target_nationality = db.Column(db.Unicode(255))
target_education = db.Column(db.Unicode(255))
target_occupation = db.Column(db.Unicode(255))
target_interest = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
agegroup = db.relationship('AgeGroupModel')
gender = db.relationship('GenderModel')
sa.orm.configure_mappers()
def __init__(self, audience_profile_name, business, age_group_id,
gender_id, target_languages, target_nationality,
target_education, target_occupation, target_interest):
self.audience_profile_name = audience_profile_name
self.business = business
self.age_group_id = age_group_id
self.gender_id = gender_id
self.target_languages = target_languages
self.target_nationality = target_nationality
self.target_education = target_education
self.target_occupation = target_occupation
self.target_interest = target_interest
def json(self):
return {
'id': self.target_audience_profile_id,
'name': self.audience_profile_name,
'token': self.token
}
@classmethod
def find_by_id(cls, target_audience_profile_id):
return cls.query.filter_by(
target_audience_profile_id=target_audience_profile_id).first()
@classmethod
def find_by_name(cls, audience_profile_name):
return cls.query.filter_by(
audience_profile_name=audience_profile_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
schema = {
'audience_profile_name': {
'required': True,
'empty': False,
'type': 'string'
},
'business': {
'required': True,
'empty': False,
'type': 'string'
},
'age_group_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'gender_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'target_languages': {
'required': True,
'empty': False,
'type': 'string'
},
'target_nationality': {
'required': True,
'empty': False,
'type': 'string'
},
'target_education': {
'required': True,
'empty': False,
'type': 'string'
},
'target_occupation': {
'required': True,
'empty': False,
'type': 'string'
},
'target_interest': {
'required': True,
'empty': False,
'type': 'string'
}
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
class UsersModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
email = db.Column(db.Unicode(255))
password = db.Column(db.Unicode(55))
user_type_id = db.Column(db.Integer)
company_name = db.Column(db.Unicode(255))
first_name = db.Column(db.Unicode(55))
last_name = db.Column(db.Unicode(55))
phone = db.Column(db.Unicode(10))
title = db.Column(db.Unicode(255))
owner_manager = db.Column(db.Unicode(255))
yearly_budget = db.Column(db.Integer)
logo = db.Column(db.Unicode(255))
city = db.Column(db.Unicode(255))
country_id = db.Column(db.Integer)
address = db.Column(db.Unicode(255))
timezone = db.Column(db.Unicode(255))
level = db.Column(db.Unicode(255))
permission = db.Column(db.Unicode(255))
assigned_brands = db.Column(db.Unicode(255))
assigned_products = db.Column(db.Unicode(255))
assigned_services = db.Column(db.Unicode(255))
parent_user_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
sa.orm.configure_mappers()
def __init__(self, email, password, user_type_id, company_name, first_name,
last_name, phone, title, owner_manager, yearly_budget, logo,
city, country_id, address, timezone, level, permission,
assigned_brands, assigned_products, assigned_services,
parent_user_id):
self.email = email
self.password = password
self.user_type_id = user_type_id
self.company_name = company_name
self.first_name = first_name
self.last_name = last_name
self.phone = phone
self.title = title
self.owner_manager = owner_manager
self.yearly_budget = yearly_budget
self.logo = logo
self.city = city
self.country_id = country_id
self.address = address
self.timezone = timezone
self.level = level
self.permission = permission
self.assigned_brands = assigned_brands
self.assigned_products = assigned_products
self.assigned_services = assigned_services
self.parent_user_id = parent_user_id
@classmethod
def validateData(cls, data, _request):
schema = {
'email': {
'required': True,
'empty': False,
'type': 'string'
},
'password': {
'required': True,
'empty': False,
'type': 'string'
},
'user_type_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'company_name': {
'required': True,
'empty': False,
'type': 'string'
},
'first_name': {
'required': True,
'empty': False,
'type': 'string'
},
'last_name': {
'required': True,
'empty': False,
'type': 'string'
},
'phone': {
'required': True,
'empty': False,
'type': 'integer'
},
'title': {
'required': True,
'empty': False,
'type': 'string'
},
'owner_manager': {
'required': True,
'empty': False,
'type': 'string'
},
'yearly_budget': {
'required': True,
'empty': False,
'type': 'integer'
},
'logo': {
'required': True,
'empty': False,
'type': 'string'
},
'city': {
'required': True,
'empty': False,
'type': 'string'
},
'country_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'address': {
'required': True,
'empty': False,
'type': 'string'
},
'timezone': {
'required': True,
'empty': False,
'type': 'string'
},
'level': {
'required': True,
'empty': False,
'type': 'string'
},
'permission': {
'required': True,
'empty': False,
'type': 'string'
},
'assigned_brands': {
'required': True,
'empty': False,
'type': 'string'
},
'assigned_products': {
'required': True,
'empty': False,
'type': 'string'
},
'assigned_services': {
'required': True,
'empty': False,
'type': 'string'
},
'parent_user_id': {
'required': True,
'empty': False,
'type': 'integer'
},
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
def json(self):
return {'id': self.user_id, 'name': self.email, 'token': self.token}
@classmethod
def find_by_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
@classmethod
def find_by_name(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class CampaignModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'campaign'
campaign_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
campaign_name = db.Column(db.Unicode(255))
description = db.Column(db.Unicode(255))
brand_id = db.Column(db.Integer, db.ForeignKey('brands.brand_id'))
product_ids = db.Column(db.Unicode(255))
currency_id = db.Column(db.Integer)
budget_amount = db.Column(db.Integer)
objective_id = db.Column(db.Integer)
kpi_id = db.Column(db.Integer)
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
days = db.Column(db.Integer)
target_locations = db.Column(db.Unicode(255))
exclude_locations = db.Column(db.Unicode(255))
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
barnd = db.relationship('BrandsModel')
sa.orm.configure_mappers()
def __init__(self, campaign_name, description, brand_id, product_ids,
currency_id, budget_amount, objective_id, kpi_id,
target_locations, exclude_locations):
self.campaign_name = campaign_name
self.description = description
self.brand_id = brand_id
self.product_ids = product_ids
self.currency_id = currency_id
self.budget_amount = budget_amount
self.objective_id = objective_id
self.kpi_id = kpi_id
self.target_locations = target_locations
self.exclude_locations = exclude_locations
def json(self):
return {
'id': self.campaign_id,
'name': self.campaign_name,
'token': self.token
}
@classmethod
def find_by_id(cls, campaign_id):
return cls.query.filter_by(campaign_id=campaign_id).first()
@classmethod
def find_by_name(cls, campaign_name):
return cls.query.filter_by(campaign_name=campaign_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
schema = {
'campaign_name': {
'required': True,
'empty': False,
'type': 'string'
},
'description': {
'required': True,
'empty': False,
'type': 'string'
},
'brand_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'product_ids': {
'required': True,
'empty': False,
'type': 'string'
},
'currency_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'budget_amount': {
'required': True,
'empty': False,
'type': 'integer'
},
'objective_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'kpi_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'target_locations': {
'required': True,
'empty': False,
'type': 'string'
},
'exclude_locations': {
'required': True,
'empty': False,
'type': 'string'
}
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
class BrandsModel(db.Model, VersioningMixin):
__versioned__ = {}
__tablename__ = 'brands'
brand_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.Unicode(80))
brand_name = db.Column(db.Unicode(255), nullable=True)
user_id = db.Column(db.Integer)
industry_id = db.Column(db.Integer, db.ForeignKey('industry.industry_id'))
brand_category_id = db.Column(db.Integer)
created_by = db.Column(db.Integer)
created_on = db.Column(db.DateTime)
modified_by = db.Column(db.Integer)
modified_on = db.Column(db.DateTime)
deleted_by = db.Column(db.Integer)
deleted_on = db.Column(db.DateTime)
industry = db.relationship('IndustryModel')
sa.orm.configure_mappers()
def __init__(self, brand_name, user_id, industry_id, brand_category_id):
self.brand_name = brand_name
self.user_id = user_id
self.industry_id = industry_id
self.brand_category_id = brand_category_id
def json(self):
return {
'id': self.brand_id,
'name': self.brand_name,
'token': self.token
}
@classmethod
def find_by_id(cls, brand_id):
return cls.query.filter_by(brand_id=brand_id).first()
@classmethod
def find_by_name(cls, brand_name):
return cls.query.filter_by(brand_name=brand_name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def validateData(cls, data, _request):
if _request.method == "POST":
schema = {
'brand_name': {
'required': True,
'empty': False,
'type': 'string'
},
'industry_id': {
'required': True,
'empty': False,
'type': 'integer'
},
'brand_category_id': {
'required': True,
'empty': False,
'type': 'integer'
}
}
else:
schema = {
'brand_name': {
'required': True,
'empty': False,
'type': 'string'
}
}
v = Validator(schema)
v.allow_unknown = True
return True if (v.validate(data)) else v.errors
