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