class GeolocationModel(Model):
ip = GenericIPAddressField()
hostname = GenericIPAddressField(blank=True, null=True)
type = CharField(max_length=4)
continent_code = CharField(max_length=8)
continent_name = CharField(max_length=100)
country_code = CharField(max_length=8)
country_name = CharField(max_length=100)
region_code = CharField(max_length=8)
region_name = CharField(max_length=100)
city = CharField(max_length=100)
zip = CharField(max_length=10, blank=True, null=True)
latitude = FloatField()
longitude = FloatField()
location = ForeignKey(LocationModel, CASCADE)
def get_description_info(self):
return {
'ip': self.ip,
'city': self.city,
'region_name': self.region_name,
'country_name': self.country_name,
'continent_name': self.continent_name,
}
def __repr__(self):
return self.__class__.__name__
def test_GenericIPAddressField(self):
lazy_func = lazy(lambda: "127.0.0.1", str)
self.assertIsInstance(
GenericIPAddressField().get_prep_value(lazy_func()), str)
lazy_func = lazy(lambda: 0, int)
self.assertIsInstance(
GenericIPAddressField().get_prep_value(lazy_func()), str)
class NetworkInterface(Model):
machine = FK(_("Machine"), Machine)
purpose = NullStringField(_("Purpose"))
interface_name = NullStringField(_("Interface name"))
interface_number = PositiveIntegerField(_("Interface number"),
null=True,
blank=True)
ipv4_address = GenericIPAddressField(_("IPv4 address"),
protocol='IPv4',
null=True,
blank=True)
ipv4_mask = NullStringField(_("IPv4 mask"))
ipv6_address = GenericIPAddressField(_("IPv6 address"),
protocol='IPv6',
null=True,
blank=True)
switch_port = NullStringField(_("Switch port"))
pvid = NullStringField(_("PVID"))
untag = NullStringField(_("Untag"))
tag = NullStringField(_("Tag"))
service = NullFK(_("Service"), Service)
class Meta:
verbose_name = _('Network interface')
verbose_name_plural = _('Network interfaces')
def __str__(self):
return "%s: %s/%s" % (self.purpose, self.ipv4_address, self.ipv4_mask)
class Comment(Model):
"""
Response to a Post.
Consists of a user-submitted message containing the User's details and the date and time it was submitted.
Attributes:
description: User-submitted message. Limited to 512 characters.
author: UUID of the Comments's author.
ip: IPv4 or IPv6 address that originated the Comment. Normalized following RFC 4291.
timestamp: The Comment's publication time. See RFC 3339.
post: UUID of the Post replied to.
"""
description = TextField(max_length=512)
author = ForeignKey(User, on_delete=CASCADE)
ip = GenericIPAddressField()
timestamp = DateTimeField(auto_now_add=True)
post = ForeignKey(Post, on_delete=CASCADE)
parent = ForeignKey('self', on_delete=CASCADE, blank=True, null=True)
@property
def owner(self):
"""
Used to determine the User(s) allowed to update the Comment.
See IsOwnerOrReadOnly permission class.
Returns:
Django User that authored the Comment.
"""
return self.author
def __str__(self):
return self.content
class Donor(Model):
date_entered = DateTimeField('date taken', auto_now_add=True, editable=False, blank=True,
null=True)
entered_from_address = GenericIPAddressField(unpack_ipv4=True, blank=True,
null=True, editable=False)
first_name = CharField(max_length=200)
last_name = CharField(max_length=200)
company_name = CharField(max_length=200, blank=True, null=True,
verbose_name="Company name (optional)")
email_address = EmailField(max_length=200)
street_address1 = CharField(
max_length=150, verbose_name="street address line 1")
street_address2 = CharField(max_length=150, null=True, blank=True,
verbose_name="street address line 2")
city = CharField(max_length=100, verbose_name='city')
state = ForeignKey(State)
zip_code = CharField(max_length=10, validators=[validate_zip_code])
phone_number = CharField(max_length=15, blank=True, null=True,
validators=[validate_phone], verbose_name="Phone number (optional)")
adopted_children = ManyToManyField(Child, blank=True)
adopted_families = ManyToManyField(Family, blank=True)
adopted_programs = ManyToManyField(Program, blank=True)
adopted_wishlist = ManyToManyField(GeneralWishlistItem, through='DonorGeneralWishlist',
verbose_name="Adopted wishlist items", blank=True)
def __unicode__(self):
return self.first_name + " " + self.last_name + " in " + self.city
class Test(Model):
name = CharField(max_length=20)
owner = ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
on_delete=CASCADE)
public = BooleanField(default=False)
date = DateField(null=True, blank=True)
datetime = DateTimeField(null=True, blank=True)
permission = ForeignKey('auth.Permission',
null=True,
blank=True,
on_delete=CASCADE)
# We can’t use the exact names `float` or `decimal` as database column name
# since it fails on MySQL.
a_float = FloatField(null=True, blank=True)
a_decimal = DecimalField(null=True,
blank=True,
max_digits=5,
decimal_places=2)
bin = BinaryField(null=True, blank=True)
ip = GenericIPAddressField(null=True, blank=True)
duration = DurationField(null=True, blank=True)
uuid = UUIDField(null=True, blank=True)
class Meta(object):
ordering = ('name', )
class ClientData(models.Model):
class Meta:
app_label = "rflocator"
ip = GenericIPAddressField()
user = models.ForeignKey(User)
loc_lat = models.FloatField('GPS Latitude', blank=True, null=True)
loc_lon = models.FloatField('GPS Longitude', blank=True, null=True)
loc_acc = models.FloatField('GPS Accuracy', blank=True, null=True)
loc_tms = models.IntegerField('GPS Fix Time', blank=True, null=True)
loc_spd = models.FloatField('GPS Speed', blank=True, null=True)
loc_alt = models.FloatField('GPS Altitude', blank=True, null=True)
loc_network_lat = models.FloatField('Network Latitude', blank=True, null=True)
loc_network_lon = models.FloatField('Network Longitude', blank=True, null=True)
loc_network_acc = models.FloatField('Network Accuracy', blank=True, null=True)
loc_network_tms = models.IntegerField('Network Fix Time', blank=True, null=True)
cellid = models.CharField('Network Cell Id', blank=True, null=True, max_length=200)
cellsig = models.IntegerField('Network Cell Signal', blank=True, null=True)
times = models.IntegerField('Device Time', blank=True, null=True)
devid = models.CharField('Device Id', max_length=200)
ups = models.IntegerField('Device Uptime')
batt = models.SmallIntegerField('Battery', blank=True, null=True)
cpufreq = models.IntegerField('Cpu Freq', blank=True, null=True)
qtime = models.IntegerField('Queue time', blank=True, null=True)
source = models.CharField('Source', max_length=100)
modified = DateTimeField(auto_now=True)
created = DateTimeField(auto_now_add=True)
log = models.TextField(null=True, blank=True)
def __str__(self):
return u"{0.created} {0.ip}".format(self)
class TestModelFields(Model):
big_int = BigIntegerField()
yesno = BooleanField()
title = CharField(max_length=150)
csv_data = CommaSeparatedIntegerField(max_length=255)
when = DateField()
when_accurate = DateTimeField()
amount = DecimalField(max_digits=8, decimal_places=4)
email = EmailField()
upload = FileField(upload_to='test')
path = FilePathField(path=d.APP_DIR, recursive=False, match=".json$")
inaccurate = FloatField()
img = ImageField(upload_to='test')
ip = IPAddressField()
better_ip = GenericIPAddressField(protocol='both')
yesnomaybe = NullBooleanField(default=None)
posint = PositiveIntegerField()
small_posint = PositiveSmallIntegerField()
slug = SlugField()
small_int = SmallIntegerField()
content = TextField()
when_time = TimeField()
web_address = URLField()
user = ForeignKey('auth.User')
groups = ManyToManyField('auth.Group')
one_to_one = OneToOneField('auth.Permission')
class Meta:
verbose_name = 'test model fields'
verbose_name_plural = 'test model fields'
class Test(Model):
name = CharField(max_length=20)
owner = ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
on_delete=SET_NULL)
public = BooleanField(default=False)
date = DateField(null=True, blank=True)
datetime = DateTimeField(null=True, blank=True)
permission = ForeignKey('auth.Permission',
null=True,
blank=True,
on_delete=PROTECT)
# We can’t use the exact names `float` or `decimal` as database column name
# since it fails on MySQL.
a_float = FloatField(null=True, blank=True)
a_decimal = DecimalField(null=True,
blank=True,
max_digits=5,
decimal_places=2)
bin = BinaryField(null=True, blank=True)
ip = GenericIPAddressField(null=True, blank=True)
duration = DurationField(null=True, blank=True)
uuid = UUIDField(null=True, blank=True)
try:
from django.db.models import JSONField
json = JSONField(null=True, blank=True)
except ImportError:
pass
class Meta:
ordering = ('name', )
class Message(Model):
created = DateTimeField(auto_now_add=True)
modified = DateTimeField(auto_now=True)
name = CharField(max_length=64)
email = EmailField()
message = TextField()
sender_ip = GenericIPAddressField()
class Order(Model):
INITIATED = 'INITIATED'
PAYMENT_RECEIVED = 'PAYMENT_RECEIVED'
FILE_LINKS_SENT = 'FILE_LINKS_SENT'
STATUS_CHOICES = [(INITIATED, 'Initiated'),
(PAYMENT_RECEIVED, 'Payment Received')]
created = DateTimeField(auto_now_add=True)
modified = DateTimeField(auto_now=True)
uuid = UUIDField(default=uuid.uuid4, unique=True, editable=False)
status = CharField(max_length=24,
choices=STATUS_CHOICES,
default=INITIATED)
initiator_ip = GenericIPAddressField()
paypay_ipn = ForeignKey(PayPalIPN,
on_delete=PROTECT,
null=True,
related_name='order')
first_name = CharField(max_length=256, blank=True)
last_name = CharField(max_length=256, blank=True)
email = EmailField(blank=True)
total = DecimalField(max_digits=5, decimal_places=2)
@property
def order_number(self):
return 1000 + self.pk
@property
def full_name(self):
return '{} {}'.format(self.first_name, self.last_name)
@property
def items_ordered(self):
return ', '.join(str(i) for i in self.items.all())
class Client(Model):
name = CharField(max_length=255, default=None)
ip = GenericIPAddressField(max_length=255, null=True)
port = IntegerField(default=6800, blank=True, null=True)
description = TextField(blank=True, null=True)
created_at = DateTimeField(auto_now_add=True)
updated_at = DateTimeField(auto_now=True)
class Post(Model):
"""
Discussion topic within a Board.
Consists of a user-submitted message containing the User's details and the date and time it was submitted.
Attributes:
title: The Post's title. Limited to 32 characters.
description: Summary of the intended discussion. Limited to 512 characters.
author: UUID of the Post's author.
ip: IPv4 or IPv6 address that originated the Post. Normalized following RFC 4291.
timestamp: The Post's publication time. See RFC 3339.
board: UUID of the Post's discussion Board.
"""
title = CharField(max_length=32)
description = TextField(max_length=512)
author = ForeignKey(User, on_delete=CASCADE)
ip = GenericIPAddressField()
timestamp = DateTimeField(auto_now_add=True)
board = ForeignKey(Board, on_delete=CASCADE)
@property
def owner(self):
"""
Used to determine the User(s) allowed to update the Post.
See IsOwnerOrReadOnly permission class.
Returns:
Django User that authored the Post.
"""
return self.author
def __str__(self):
return self.title
class RegionControllerProcessEndpoint(CleanSave, TimestampedModel):
"""`RegionControllerProcessEndpoint` is a RPC endpoint on the
`RegionControllerProcess` one endpoint is created per IP address on the
`RegionControllerProcess`.
:ivar process: `RegionControllerProcess` for this endpoint.
:ivar address: IP address for the endpoint.
:ivar port: Port number of the endpoint.
"""
class Meta(DefaultMeta):
"""Needed recognize this model."""
unique_together = ("process", "address", "port")
process = ForeignKey(
RegionControllerProcess,
null=False,
blank=False,
related_name="endpoints",
on_delete=CASCADE,
)
address = GenericIPAddressField(null=False, blank=False, editable=False)
port = IntegerField(
default=0, validators=[MinValueValidator(0),
MaxValueValidator(65535)])
class BaseAttribute(Model):
ip = GenericIPAddressField()
time = DateTimeField(default=timezone.now)
class Meta:
abstract = True
class LoginAttempt(models.Model):
username = models.CharField(_("username"),
max_length=255,
blank=True,
null=True)
password = models.CharField(_("password"),
max_length=255,
blank=True,
null=True)
ip_address = GenericIPAddressField(_("ip address"), blank=True, null=True)
session_key = models.CharField(_("session key"),
max_length=50,
blank=True,
null=True)
user_agent = models.TextField(_("user-agent"), blank=True, null=True)
timestamp = models.DateTimeField(_("timestamp"), auto_now_add=True)
path = models.TextField(_("path"), blank=True, null=True)
class Meta:
verbose_name = _("login attempt")
verbose_name_plural = _("login attempts")
ordering = ('timestamp', )
def __str__(self):
return self.username
class Submission(Model):
"""
提交记录。
"""
# 提交记录状态码和对应的状态的映射
STATUS_CHOICES = (
('PD', 'Pending'),
('PDR', 'Pending Rejudge'),
('CP', 'Compiling'),
('CE', 'Compile Error'),
('CD', 'Compile Done'),
('RJ', 'Running & Judging'),
('RN', 'Running'),
('RE', 'Runtime Error'),
('TLE', 'Time Limit Exceed'),
('MLE', 'Memory Limit Exceed'),
('OLE', 'Output Limit Exceed'),
('RD', 'Running Done'),
('JD', 'Judging'),
('WA', 'Wrong Answer'),
('PE', 'Presentation Error'),
('AC', 'Accepted'),
)
# 编号
id = BigAutoField(primary_key=True)
# 所属题目
problem = ForeignKey(Problem, related_name='submissions', to_field='id')
# 所属编程环境
environment = ForeignKey('Environment', related_name='submissions', to_field='id')
# 运行花费的时间
time = IntegerField(default=-1)
# 运行花费的内存
memory = IntegerField(default=-1)
# 代码长度
length = IntegerField(default=-1)
# 提交的用户
user = CharField(max_length=150, null=True)
# 提交所属的竞赛
contest = CharField(max_length=150, null=True)
# 来自哪个用户端
client = ForeignKey('Client', related_name='submissions', to_field='id', null=True, on_delete=SET_NULL)
# 状态，由各组测试数据的状态合成的总状态
status = CharField(max_length=4, default='PD', choices=STATUS_CHOICES)
# 是否完成了评测
finished = BooleanField(default=False)
# 提交时间
submit_time = DateTimeField(auto_now_add=True)
# 状态更新时间
update_time = DateTimeField(auto_now=True)
# 提交的ip
ip = GenericIPAddressField()
# 哪一个评测机评测了这条提交
judge = ForeignKey('Judge', related_name='submissions', to_field='id', null=True)
class DNS(Model):
class Meta:
verbose_name = '[Range] DNS Server'
verbose_name_plural = '[Range] DNS Servers'
ip = GenericIPAddressField('DNS Server Address',
protocol='both',
unpack_ipv4=True)
def __str__(self):
return '[DNS] %s' % str(self.ip)
class ReportItem(CerberusModel):
"""
Fraudulent item found in a `abuse.models.Report`
"""
ITEM_TYPE = (("IP", "Ip"), ("FQDN", "Fqdn"), ("URL", "Url"))
report = ForeignKey("Report",
null=False,
related_name="reportItemRelatedReport")
rawItem = TruncatedCharField(db_index=True, max_length=4095)
itemType = TruncatedCharField(max_length=4, null=True, choices=ITEM_TYPE)
fqdn = TruncatedCharField(null=True, max_length=255)
fqdnResolved = GenericIPAddressField(db_index=True, null=True)
fqdnResolvedReverse = TruncatedCharField(null=True, max_length=255)
ip = GenericIPAddressField(null=True)
ipReverse = TruncatedCharField(db_index=True, null=True, max_length=255)
ipReverseResolved = GenericIPAddressField(null=True)
url = TruncatedCharField(null=True, max_length=4095)
date = DateTimeField(auto_now=True, null=True, editable=True)
def test_update_generic_ip_address(self):
CaseTestModel.objects.update(generic_ip_address=Case(
When(integer=1, then=Value('1.1.1.1')),
When(integer=2, then=Value('2.2.2.2')),
output_field=GenericIPAddressField(),
), )
self.assertQuerysetEqual(CaseTestModel.objects.all().order_by('pk'),
[(1, '1.1.1.1'), (2, '2.2.2.2'), (3, None),
(2, '2.2.2.2'), (3, None), (3, None),
(4, None)],
transform=attrgetter('integer',
'generic_ip_address'))
class Node(models.Model):
node_name = CharField(max_length=255, default=None)
node_ip = GenericIPAddressField(max_length=255, null=True)
node_port = IntegerField(default=6800, blank=True, null=True)
auth = IntegerField(default=0, blank=True, null=True)
description = TextField(blank=True, null=True)
username = CharField(max_length=255, blank=True, null=True)
password = CharField(max_length=255, blank=True, null=True)
created_at = DateTimeField(auto_now_add=True)
updated_at = DateTimeField(auto_now=True)
node_status = TextField(blank=True, null=True)
is_lock = IntegerField(default=1, blank=True, null=True)
class ForwardDNSServer(CleanSave, TimestampedModel):
"""A `ForwardDNSServer`.
:ivar ip_address: The IP address of the forward DNS server to forward queries to.
:ivar domains: A many to many reference to domains that forward to this server."""
objects = ForwardDNSServerManager()
ip_address = GenericIPAddressField(
null=False, default=None, editable=False, unique=True
)
domains = ManyToManyField(Domain)
class AbstractUser(AbstractBaseUser):
"""
Remember that password and last_login are inherited from AbstractBaseUser.
"""
username = LowerCaseCharField(max_length=50,
db_index=True,
unique=True,
validators=[
Common.alphanumeric(),
Common.min_length(5),
Common.starts_with_letter(),
])
email = models.EmailField(unique=True)
date_joined = models.DateTimeField(auto_now_add=True)
first_name = models.CharField(max_length=300, blank=True, default='')
last_name = models.CharField(max_length=300, blank=True, default='')
ip_address = GenericIPAddressField(null=True)
is_staff = models.BooleanField(default=False)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
objects = UserManager()
@property
def is_active(self):
now = datetime.datetime.utcnow().replace(tzinfo=utc)
last_seen = self.date_joined if self.last_login is None else \
max(self.date_joined, self.last_login)
return (now - last_seen).days <= constants.ACTIVE_DAYS
@property
def is_superuser(self):
return self.is_staff
def get_full_name(self):
return '{0} {1}'.format(self.first_name, self.last_name)
def get_short_name(self):
return self.first_name
def has_perm(self, perm, obj=None):
return True
def has_module_perms(self, app_label):
return True
def __str__(self):
return '{0}'.format(self.username)
class Meta:
abstract = True
class ServiceActionJob(CerberusModel):
"""
`abuse.models.ServiceAction` execution state
"""
action = ForeignKey(ServiceAction, null=False)
asynchronousJobId = TruncatedCharField(null=True, max_length=128)
actionTodoId = IntegerField(null=True)
status = TruncatedCharField(null=False, max_length=32, default="pending")
comment = TruncatedCharField(null=True, max_length=256)
creationDate = DateTimeField(null=False)
executionDate = DateTimeField(null=True)
ip = GenericIPAddressField(null=True)
class TrackerInfos(Model):
"""
Contain all the infos entry for target tracker.
:param target_tracker(ForeignKey): Link to :func:`tracker class
<phishing.models.tracker.Tracker>`
:param created_at(DateTimeField): Date of tracker's creation
:param ip(GenericIPAddressField): Get the target's IP
:param raw(TextField): Raw data (contains more information)
:param referer(TextField): Referer web if target open the email
with web browser
:param user_agent(TextField): Get the target's user_agent
"""
target_tracker = ForeignKey('Tracker',
related_name='tracker_infos',
on_delete=CASCADE)
created_at = DateTimeField(auto_now_add=True)
ip = GenericIPAddressField(blank=True, null=True)
raw = TextField(blank=True, null=True)
referer = TextField(blank=True, null=True)
user_agent = TextField(blank=True, null=True)
def __str__(self):
"""
Print function for TrackerInfos
:return text: Print tracker's information (not all the infos)
"""
return str(self.target_tracker)
@classmethod
def create(cls, http_request=None, **kwargs):
"""
Create info entry (for a target tracker)
:param http_request: django http request object
:param kwargs: optional value to pass to constructor
:return: TrackerInfos created object
"""
# extract standard info to http request
if http_request:
meta = http_request.META
kwargs['user_agent'] = meta.get('HTTP_USER_AGENT')
kwargs['referer'] = meta.get('HTTP_REFERER')
forward_ip = meta.get('HTTP_X_FORWARDED_FOR', '').split(',')[0]
kwargs['ip'] = forward_ip or meta.get('REMOTE_ADDR')
return cls.objects.create(**kwargs)
class Meta:
ordering = ['-created_at']
def clean(self, value):
if value is None:
return None
else:
ips = re.split(self.separators, value)
ips = [ip.strip() for ip in ips if ip != ""]
for ip in ips:
try:
GenericIPAddressField().clean(ip, model_instance=None)
except ValidationError:
raise ValidationError(
"Invalid IP address: %s; provide a list of "
"space-separated IP addresses" % ip)
return " ".join(ips)
class Guess(models.Model):
x = models.IntegerField(validators=[
validators.MinValueValidator(0),
validators.MaxValueValidator(BOARD_WIDTH)
])
y = models.IntegerField(validators=[
validators.MinValueValidator(0),
validators.MaxValueValidator(BOARD_HEIGHT)
])
# empty (incorrect) or 1 letter
key = models.CharField(max_length=1)
ip = GenericIPAddressField(null=True)
created_on = models.DateTimeField(auto_now_add=True)
class Ip(Model):
address = GenericIPAddressField(verbose_name='IP Address', unique=True)
#address_value = IntegerField(verbose_name='IP Address Value')
country = CharField(max_length=10,
verbose_name='Country Code',
null=True,
blank=True)
def __unicode__(self):
return u'%s (%s)' % (unicode(self.address), self.country)
class Meta:
ordering = ["country", "address"]
verbose_name = "IP Address"
verbose_name_plural = "IP Addresses"
class WeatherUsage(Model):
ip = GenericIPAddressField()
location = CharField(max_length=255)
lat = CharField(max_length=50)
lng = CharField(max_length=50)
temperature = DecimalField(decimal_places=3, max_digits=5)
created_at = DateField(auto_now=True)
class Meta:
verbose_name = _("Weather Usage")
verbose_name_plural = _("Weather Usages")
def __str__(self):
return 'Temperature at {} is {} <b>C˚</b>.'.format(
self.location.title(), self.temperature)
class ChatSession(Model):
first_name = CharField(max_length=30,
blank=False,
verbose_name="First Name",
validators=[alphanumeric])
last_name = CharField(max_length=30,
blank=False,
verbose_name="Last Name",
validators=[alphanumeric])
date_of_birth = CharField(max_length=30,
blank=True,
null=True,
verbose_name="Date of Birth")
user = ForeignKey(settings.AUTH_USER_MODEL,
blank=True,
null=True,
on_delete=DO_NOTHING)
ip_address = GenericIPAddressField(blank=True, null=True)
session_id = CharField(max_length=64, blank=True, null=True)
created = DateTimeField(auto_now_add=True, blank=True, editable=False)
last_replied = DateTimeField(auto_now_add=True, blank=True, editable=False)
def get_messages(self, include_sent=False):
if include_sent:
messages = ChatMessage.objects.filter(
session=self).order_by("sent")
else:
messages = ChatMessage.objects.filter(session=self,
shown=False).order_by("sent")
message_count = messages.count()
if message_count > 0:
self.last_replied = messages[message_count - 1].sent
self.save()
return messages
def delete(self, using=None, keep_parents=False):
ChatMessage.objects.filter(session_id=self.pk).delete()
super(ChatSession, self).delete(using, keep_parents)
@property
def expired(self):
session_expiration = datetime.datetime.now() - datetime.timedelta(
days=1)
return self.last_replied < session_expiration