class Subscription(db.Model):
"""Model class to represent ATT subscriptions"""
__tablename__ = "subscriptions"
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(10))
status = db.Column(ENUM(SubscriptionStatus), default=SubscriptionStatus.new)
activation_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
expiry_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
plan_id = db.Column(db.String(30), db.ForeignKey("plans.id"), nullable=False)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
def __repr__(self): # pragma: no cover
return (
f"<{self.__class__.__name__}: {self.id} ({self.status}), "
f"phone_number: {self.phone_number or '[no phone number]'}, ",
f"plan: {self.plan_id}>"
)
@classmethod
def get_subscriptions(cls, **kwargs):
"""Gets a list of Subscription objects using given kwargs
Generates query filters from kwargs param using base class method
Args:
kwargs: key value pairs to apply as filters
Returns:
list: objects returned from query result
"""
return cls.query.filter(**kwargs).all()
class ServiceCode(db.Model):
"""Model class to represent service codes"""
__tablename__ = "service_codes"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(200))
subscriptions = db.relationship(
"Subscription",
secondary=subscriptions_service_codes,
primaryjoin=
"ServiceCode.id==subscriptions_service_codes.c.service_code_id",
secondaryjoin=
"Subscription.id==subscriptions_service_codes.c.subscription_id",
back_populates="service_codes",
cascade="all,delete")
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id}, "
f"{self.name}: ({self.description})>")
@classmethod
def get_data_blocking_code(cls):
"""Gets the data blocking service code"""
return cls.get_one(name=cls.get_data_blocking_code_name())
@classmethod
def get_data_blocking_code_name(cls):
"""Gets the name of the data blocking service code"""
return current_app.config.get("DATA_BLOCKING_CODE")
class Plan(db.Model):
"""Model class to represent mobile service plans"""
__tablename__ = "plans"
id = db.Column(db.String(30), primary_key=True)
description = db.Column(db.String(200))
# amount of data available for a given billing cycle
mb_available = db.Column(db.BigInteger)
is_unlimited = db.Column(db.Boolean)
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id} ({self.description})>")
class Subscription(db.Model):
"""Model class to represent ATT subscriptions"""
__tablename__ = "subscriptions"
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(10))
status = db.Column(ENUM(SubscriptionStatus),
default=SubscriptionStatus.new)
activation_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
expiry_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
plan_id = db.Column(db.String(30),
db.ForeignKey("plans.id"),
nullable=False)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
service_codes = db.relationship(
"ServiceCode",
secondary=subscriptions_service_codes,
primaryjoin=
"Subscription.id==subscriptions_service_codes.c.subscription_id",
secondaryjoin=
"ServiceCode.id==subscriptions_service_codes.c.service_code_id",
back_populates="subscriptions",
cascade="all,delete",
lazy="subquery")
data_usages = db.relationship(DataUsage, back_populates="subscription")
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id} ({self.status}), "
f"phone_number: {self.phone_number or '[no phone number]'}, ",
f"plan: {self.plan_id}>")
@classmethod
def get_subscriptions(cls, **kwargs):
"""Gets a list of Subscription objects using given kwargs
Generates query filters from kwargs param using base class method
Args:
kwargs: key value pairs to apply as filters
Returns:
list: objects returned from query result
"""
return cls.query.filter(**kwargs).all()
@property
def service_code_names(self):
"""Helper property to return names of active service codes"""
return [code.name for code in self.service_codes]
class ATTPlanVersion(db.Model):
"""Model class to represent ATT plan version
Custom versioning class to keep track of plans enabled ATT side
"""
__tablename__ = "att_plan_versions"
id = db.Column(db.Integer, primary_key=True)
subscription_id = db.Column(
db.Integer, db.ForeignKey("subscriptions.id"), nullable=False
)
subscription = db.relationship(
"Subscription", back_populates="att_plan_versions", lazy="select"
)
plan_id = db.Column(
db.String(30), db.ForeignKey("plans.id"), nullable=False
)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
start_effective_date = db.Column(db.TIMESTAMP(timezone=True), nullable=False)
end_effective_date = db.Column(db.TIMESTAMP(timezone=True), nullable=False)
mb_available = db.Column(db.BigInteger)
def __repr__(self): # pragma: no cover
return (
f"<{self.__class__.__name__}: {self.subscription_id}, "
f"{str(self.plan_id)} ({self.start_effective_date} - "
f"{self.end_effective_date}) "
)
class Counter(BaseModel):
count = db.Column(db.Integer, default=0, nullable=False)
label = db.Column(db.String(), nullable=False)
def increment(self, amount=1):
self.count += amount
self.save()
class Guild(BaseModel):
__tablename__ = 'guilds2'
query: sql.Select
id = db.Column(db.Integer, db.Sequence("user_id_seq"), primary_key=True)
guild_id = db.Column(db.BigInteger)
guild_name = db.Column(db.String(200))
class ServiceCode(db.Model):
"""Model class to represent service codes"""
__tablename__ = "service_codes"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(200))
subscriptions = db.relationship(
"Subscription",
secondary=subscriptions_service_codes,
primaryjoin=
"ServiceCode.id==subscriptions_service_codes.c.service_code_id",
secondaryjoin=
"Subscription.id==subscriptions_service_codes.c.subscription_id",
back_populates="service_codes",
cascade="all,delete")
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id}, "
f"{self.name}: ({self.description})>")
class Counter(BaseModel):
count = db.Column(db.Integer, default=0, nullable=False)
label = db.Column(db.String(), nullable=False)
RESET_THRESHOLD = 1000000000
def increment(self, amount=1):
self.count += amount
if self.count > self.RESET_THRESHOLD:
self.count = 0
self.save()
class Airport(db.Model):
"""Model class to represent Airport"""
__tablename__ = "airport"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
city = db.Column(db.String(50), nullable=False)
country = db.Column(db.String(50), nullable=False)
iata = db.Column(db.String(255))
icao = db.Column(db.String(255))
latitude = db.Column(db.String(255))
longitude = db.Column(db.String(255))
altitude = db.Column(db.String(255))
timezone = db.Column(db.String(50))
dst = db.Column(db.String(50))
tz = db.Column(db.String(50))
type = db.Column(db.String(50))
source = db.Column(db.String(50))
is_deleted = db.Column(db.Boolean, default=False)
@classmethod
def from_upload(cls, data):
return cls(**data)
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id} ({self.name})>")
def update_current_object(self, data):
for key, value in data.items():
setattr(self, key, value)
db.session.commit()
@classmethod
def update(cls, data, sid):
airport = get_object_or_404(
cls.query.only_not_deleted().with_for_update(), sid)
airport.update_current_object(data)
return airport
@classmethod
def delete(cls, sid):
airport = get_object_or_404(
cls.query.only_not_deleted().with_for_update(), sid)
airport.is_deleted = True
db.session.commit()
@classmethod
def create(cls, data):
airport = Airport(**data)
db.session.add(airport)
db.session.commit()
return airport
class Subscription(db.Model):
"""Model class to represent ATT subscriptions"""
__tablename__ = "subscriptions"
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(10))
status = db.Column(ENUM(SubscriptionStatus),
default=SubscriptionStatus.new)
plan_id = db.Column(db.String(30),
db.ForeignKey("plans.id"),
nullable=False)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
service_codes = db.relationship(
"ServiceCode",
secondary="subscriptions_service_codes",
primaryjoin=
"Subscription.id==subscriptions_service_codes.c.subscription_id",
secondaryjoin=
"ServiceCode.id==subscriptions_service_codes.c.service_code_id",
back_populates="subscriptions",
cascade="all,delete",
lazy="subquery")
data_usages = db.relationship("DataUsage", back_populates="subscription")
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id} ({self.status}), "
f"phone_number: {self.phone_number or '[no phone number]'}, ",
f"plan: {self.plan_id}>")
@classmethod
def get_subscriptions(cls, **kwargs):
"""Gets a list of Subscription objects using given kwargs
Generates query filters from kwargs param using base class method
Args:
kwargs: key value pairs to apply as filters
Returns:
list: objects returned from query result
"""
return cls.query.filter(**kwargs).all()
def block_subscription(self):
""" Add Data Block service code to this subscription"""
self.service_codes.append(get_object_or_404(ServiceCode, 1))
db.session.commit()
def unblock_subscription(self):
""" Remove Data Block service code from this subscription"""
self.service_codes.remove(get_object_or_404(ServiceCode, 1))
db.session.commit()
def sum_usage(self):
"""Return data usage in gigabytes for this subscription"""
if self.status == "SubscriptionStatus.new":
return 0
from src.models.usages import DataUsage
return DataUsage.query \
.with_entities(func.sum(DataUsage.mb_used) / 1024) \
.filter(DataUsage.subscription_id == self.id) \
.scalar()
def check_overflow(self):
"""Return if the data usage of the subscription is overflow"""
gb_used = self.sum_usage()
if self.plan_id != "3" and self.plan.mb_available / 1024 < float(
0 if gb_used is None else gb_used):
return True
return False
def is_blocked(self):
"""Return if subscription include data block service code"""
for service_code in self.service_codes:
if service_code.id == 1:
return True
return False
class Subscription(db.Model):
"""Model class to represent ATT subscriptions"""
__tablename__ = "subscriptions"
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(10))
status = db.Column(ENUM(SubscriptionStatus),
default=SubscriptionStatus.new)
activation_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
expiry_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
plan_id = db.Column(db.String(30),
db.ForeignKey("plans.id"),
nullable=False)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
service_codes = db.relationship(
"ServiceCode",
secondary=subscriptions_service_codes,
primaryjoin=
"Subscription.id==subscriptions_service_codes.c.subscription_id",
secondaryjoin=
"ServiceCode.id==subscriptions_service_codes.c.service_code_id",
back_populates="subscriptions",
cascade="all,delete",
lazy="subquery")
data_usages = db.relationship(DataUsage, back_populates="subscription")
versions = db.relationship("SubscriptionVersion",
back_populates="subscription",
order_by="SubscriptionVersion.date_created")
def __repr__(self): # pragma: no cover
return (f"<{self.__class__.__name__}: {self.id} ({self.status}), "
f"phone_number: {self.phone_number or '[no phone number]'}, ",
f"plan: {self.plan_id}>")
@classmethod
def get_subscriptions(cls, **kwargs):
"""Gets a list of Subscription objects using given kwargs
Generates query filters from kwargs param using base class method
Args:
kwargs: key value pairs to apply as filters
Returns:
list: objects returned from query result
"""
return cls.query.filter_by(**kwargs).all()
@property
def service_code_names(self):
"""Helper property to return names of active service codes"""
return [code.name for code in self.service_codes]
@classmethod
def get_subscriptions_in_cycle(cls, billing_cycle, subscription_id=None):
"""The function filters subscriptions that have versions within given billing cycle. If subscription_id
argument has been passed the function returns queryset that is filtered with this id.
Args:
billing_cycle (BillingCycle): object of BillingCycle
subscription_id (int, optional): id of Subscription object, default is None
Returns:
sqlalchemy.orm.query.Query: returns queryset for subscription that have versions withing given
billing cycle with joined versions array to every subscription (ordered by date_created).
"""
query = cls.query
if subscription_id is not None:
query = query.filter_by(id=subscription_id)
query = query \
.outerjoin(
SubscriptionVersion,
and_(
Subscription.id == SubscriptionVersion.subscription_id,
SubscriptionVersion.date_start >= billing_cycle.start_date,
SubscriptionVersion.date_end <= billing_cycle.end_date,
),
) \
.options(contains_eager(cls.versions))
return query
