class BuildWorker(BaseModel):
"""Manages deployment build workers.
These are short lived spot instances, built from Chiliseed ami, which have
the tools to build docker image and push it to ECR of the service.
"""
organization = models.ForeignKey(
"organizations.Organization",
related_name="service_builders",
on_delete=models.CASCADE,
)
project = models.ForeignKey(
Project,
related_name="builders",
on_delete=models.CASCADE,
null=True,
blank=False,
)
service = models.ForeignKey(
Service, related_name="build_workers", on_delete=models.CASCADE
)
launched_at = models.DateTimeField(null=True)
instance_id = models.CharField(max_length=80, null=True)
ssh_key_name = EncryptedTextField(max_length=150, null=False)
public_ip = EncryptedTextField(max_length=50, default="")
is_deleted = models.BooleanField(default=False)
deleted_at = models.DateTimeField(null=True, blank=True)
def __str__(self):
return f"#{self.id} | Service: {self.service} | Launched at: {self.launched_at}"
class WalletAccount(models.Model):
bank_user = models.CharField(max_length=100,
blank=True,
unique=True,
default=uuid.uuid4)
user_key = EncryptedTextField()
wallet_api_token = EncryptedTextField()
balance = models.DecimalField(max_digits=10,
decimal_places=2,
default=0.00)
class TangerineClient(models.Model):
username = models.CharField(max_length=32)
password = EncryptedTextField()
securityq1 = models.CharField(max_length=1000)
securitya1 = EncryptedTextField()
securityq2 = models.CharField(max_length=1000)
securitya2 = EncryptedTextField()
securityq3 = models.CharField(max_length=1000)
securitya3 = EncryptedTextField()
def __str__(self):
return self.username
def __repr__(self):
return 'TangerineClient<{}>'.format(self.username)
def __enter__(self):
secrets_dict = {
'username': self.username,
'password': self.password,
'security_questions': {
self.securityq1: self.securitya1,
self.securityq2: self.securitya2,
self.securityq3: self.securitya3
}
}
secrets = tangerine.tangerinelib.DictionaryBasedSecretProvider(
secrets_dict)
self.client = tangerine.tangerinelib.TangerineClient(secrets)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def SyncAccounts(self):
try:
with self.client.login():
accounts = self.client.list_accounts()
for a in accounts:
TangerineAccount.objects.get_or_create(
client=self,
id=a['number'],
defaults={
'type': a['description'],
'internal_display_name': a['display_name'],
'account_balance': a['account_balance']
})
except requests.exceptions.HTTPError:
print("Couldn't sync accounts - possible server failure?")
def GetActivities(self, account_id, start, end):
with self.client.login():
return self.client.list_transactions([account_id], start, end)
class Device(models.Model):
device_name = models.CharField(max_length=100, blank=False, unique=True)
device_group = models.ForeignKey('DeviceGroup', on_delete=models.SET_NULL, null=True, default=None, blank=True)
device_ipv4 = models.CharField(max_length=100, blank=False, unique=True)
device_username = EncryptedTextField(blank=False)
device_password = EncryptedTextField(blank=False)
created_at = models.DateTimeField(auto_now_add=True, null=True)
updated_at = models.DateTimeField(auto_now=True, null=True)
def __str__(self):
return '{}'.format(self.device_name)
class PythonFunctionExecution(models.Model):
python_function = models.ForeignKey(PythonFunction,
null=True,
on_delete=models.SET_NULL)
request_user = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
on_delete=models.SET_NULL)
request_ip = EncryptedCharField(max_length=255)
input = EncryptedTextField()
output = EncryptedTextField()
code = EncryptedTextField()
time_start = models.DateTimeField(null=True, blank=True)
time_end = models.DateTimeField(null=True, blank=True)
class Payment_Method(models.Model):
card_type = models.CharField(max_length=50)
card_number = models.BigIntegerField()
card_exp_month_year = models.DateField(auto_now=False, auto_now_add=False)
card_cvc = models.IntegerField()
stripe_payment_method_id = models.CharField(max_length=50, null=True)
key = EncryptedTextField()
class Subscription(models.Model):
status = models.CharField(max_length=50)
purchase_date = models.DateField(auto_now=False, auto_now_add=False)
price_id = models.CharField(max_length=50)
stripe_subscription_id = models.CharField(max_length=50)
customer = models.ForeignKey(to=Customer, on_delete=models.CASCADE)
key = EncryptedTextField()
class Server(TimeStampedModel, StatusModel, UUIDModel):
STATUS = Choices(
('active', _('Active')),
('inactive', _('Inactive')),
)
account = models.ForeignKey(Account,
related_name="servers",
on_delete=models.CASCADE)
hostname = models.CharField(max_length=255)
public_ip = models.GenericIPAddressField(null=True, blank=True)
platform = models.CharField(max_length=255, null=True, blank=True)
capacity = models.CharField(max_length=255, null=True, blank=True)
private_info = EncryptedTextField(null=True, blank=True)
cost = models.PositiveIntegerField(default=0,
help_text="Monthly cost in whole cents")
slots = models.PositiveIntegerField(
default=10, help_text="Number of sites available on this server")
projects = models.ManyToManyField(Project, related_name="servers")
objects = ServerManager()
def get_absolute_url(self):
return reverse('servers:detail', args=(self.id, ))
@property
def available_slots(self):
return self.slots - self.slots
def __str__(self):
return self.hostname
class Secret(models.Model):
"""Postgres model for storing secrets."""
#: creation date and time
created = models.DateTimeField(auto_now_add=True, db_index=True)
#: modified date and time
modified = models.DateTimeField(auto_now=True, db_index=True)
#: user that created the secret
contributor = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.PROTECT)
#: secret handle
handle = models.UUIDField(primary_key=True,
default=uuid.uuid4,
editable=False)
#: actual secret
value = EncryptedTextField()
#: secret metadata (not encrypted)
metadata = JSONField(default=dict)
#: expiry time
expires = models.DateTimeField(null=True, db_index=True)
#: secret manager
objects = SecretManager()
class UserProfile(BaseAbstractModel):
"""This class defines a Profile model for all Users"""
QUESTION_CHOICES = (
('What is the name of your favorite childhood friend',
'What is the name of your favorite childhood friend'),
('What was your childhood nickname',
'What was your childhood nickname'),
('In what city or town did your mother and father meet',
'In what city or town did your mother and father meet'))
user = models.OneToOneField(User, on_delete=models.CASCADE)
package = models.ForeignKey(Package, on_delete=models.CASCADE)
phone = models.CharField(max_length=17, null=True, blank=False)
image = models.URLField(null=True, blank=True)
parental_lock = models.IntegerField(default=6666)
recording_time = models.IntegerField(default=30)
security_question = models.CharField(max_length=255,
null=True,
blank=False,
choices=QUESTION_CHOICES)
security_answer = EncryptedTextField(null=True)
objects = models.Manager()
active_objects = CustomQuerySet.as_manager()
def __str__(self):
return f'{self.user}\'s Profile'
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
country = models.CharField(max_length=128, null=True)
phone_number = PhoneNumberField(null=True)
# passport_number = models.TextField(null=True)
passport_number = EncryptedTextField(null=True)
encrypted_phone_number = PhoneEncryptedField(null=True, blank=True)
class Topup(models.Model):
trx_id = models.CharField(max_length=50, null=False)
ref_id = models.IntegerField(default=0)
wallet = models.ForeignKey(Wallet,
on_delete=models.CASCADE,
related_name="wallet")
bank = models.ForeignKey(Bank,
on_delete=models.CASCADE,
related_name="topup_bank")
amount = models.DecimalField(max_digits=10,
decimal_places=2,
null=True,
blank=True)
description = EncryptedTextField()
trx_date = models.DateTimeField(auto_now_add=True, auto_now=False)
def clean(self):
if self.amount < 0:
raise ValidationError("Amount must be greater than 0")
elif self.trx_id is None:
raise ValidationError("Must provide a transcation ID")
def save(self, *args, **kwargs):
self.clean()
super().save(*args, **kwargs)
def __str__(self):
return f"{self.id} : {self.wallet} - amount : {self.amount}"
class DataSource(models.Model):
objects = DataSourceManager()
id = models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True)
slug = models.SlugField(max_length=100, unique=True)
name = models.CharField(max_length=256, unique=True)
provider = models.ForeignKey(Provider)
owners = models.ManyToManyField(User, blank=True)
credentials = EncryptedTextField(default='{}')
def validate(self):
try:
credentials_json = json.loads(self.credentials)
except ValueError:
return 'credentials are not valid JSON'
try:
jsonschema.validate(credentials_json,
self.provider.credentials_schema)
except jsonschema.ValidationError as err:
return 'credentials are invalid: {}'.format(err)
return None
def clean(self, *args, **kwargs):
super(DataSource, self).clean(*args, **kwargs)
validation = self.validate()
if validation is not None:
raise ValidationError(validation)
def __str__(self):
return "{}: {}".format(self.provider.name, self.name)
class OurUsers(models.Model):
name = models.CharField(max_length=100)
social_security = EncryptedTextField(max_length=11)
my_issue = models.TextField()
class Meta:
db_table = 'OURUSERS'
class Servises(models.Model):
page_name = models.CharField('Page Name', max_length=100)
page_url = models.TextField('Page URL', validators=[URLValidator()])
user = models.TextField('User')
password = EncryptedTextField('Password')
class Meta:
ordering = ('-id', )
class SecureAuth(models.Model):
"""
SecureAuth class, encrypted keys by fernets algorithm
"""
profile = models.ForeignKey(Profile, on_delete=models.CASCADE)
key = EncryptedTextField()
def __str__(self):
return self.key
class GoogleCloudCredential(models.ModelPlus):
service_name = models.CharField(verbose_name='Service name',
max_length=255,
unique=True)
client_secret = EncryptedTextField(verbose_name='Client Secret', null=True)
credentials_content = EncryptedTextField(
verbose_name='Credentials Content', null=True, blank=True)
def create_credentials(self):
flow = InstalledAppFlow.from_client_config(
json.loads(self.client_secret), [MANGAE_OWNER_SCOPE])
creds = flow.run_console()
self.credentials_content = json.dumps({
'token': creds.token,
'refresh_token': creds.refresh_token,
'token_uri': creds.token_uri,
'client_id': creds.client_id,
'client_secret': creds.client_secret,
'scopes': creds.scopes,
})
@cached_property
def credentials(self):
if not self.credentials_content:
raise CredentialsError()
info = json.loads(self.credentials_content)
credentials = Credentials(**info)
if not credentials.valid:
if credentials.expired and credentials.refresh_token:
credentials.refresh(Request())
else:
raise CredentialsError()
return credentials
@cached_property
def service(self):
return build('docs', 'v1', credentials=self.credentials)
@cached_property
def service_drive(self):
return build('drive', 'v3', credentials=self.credentials)
class Script(BaseModel):
name = models.CharField(max_length=100, blank=False, null=False)
script = EncryptedTextField()
project = models.ForeignKey(Project,
related_name="scripts",
on_delete=models.CASCADE)
def __str__(self):
return self.name
class Player(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
club = models.ForeignKey(Club, on_delete=models.CASCADE)
lab_key = models.CharField(max_length=100, unique=True)
birthday = models.DateField()
first_name = EncryptedTextField()
last_name = EncryptedTextField()
active = models.BooleanField(default=True)
archived = models.BooleanField(default=False)
invited = models.DateTimeField(null=True, blank=True)
GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
)
gender = models.CharField(max_length=10, choices=GENDER_CHOICES)
def __str__(self):
return self.user.username
class Profile(models.Model):
user = models.OneToOneField(
User, on_delete=models.CASCADE) # name, email, password
startDate = models.DateField()
endDate = models.DateField()
token = EncryptedTextField()
trackerID = models.IntegerField()
objects = ProfileManager()
class DropboxDatastore(FileDatastore):
username = models.CharField(max_length=100)
root_path = models.CharField(max_length=500, default="", blank=True)
token_cache = EncryptedTextField()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.service = util.get_service_from_cache(json.loads(
self.token_cache))
self.path = f"/{self.root_path}/" if self.root_path else "/"
def __str__(self):
return f"{self.username} (Dropbox)"
def get_connection_details(self):
return f"Username: {self.username}, Root path: {self.root_path}"
def is_connection_valid(self):
# Since refresh tokens no not expire we assume that the connection is always valid.
return True
def get_viable_datasets(self):
viable_datasets = defaultdict(list)
search_results = self.service.files_list_folder(
"" if self.path == "/" else self.path, recursive=True)
entries = search_results.entries
# If the search results are paged, collect viable datasets from each page using the given cursor.
while search_results.has_more:
search_results = self.service.files_list_folder_continue(
search_results.cursor)
entries.extend(search_results.entries)
for entry in entries:
if entry.name.split(".")[-1].lower() in get_supported_file_types():
parent_folder = entry.path_display.split("/")[-2]
value = json.dumps({
"id": entry.id,
"name": os.path.splitext(entry.name)[0]
})
viable_datasets[parent_folder].append({
"value": value,
"display": entry.name
})
return {"Files": dict(viable_datasets)}
def _download_data(self, file_id):
file, response = self.service.files_download(file_id, rev=None)
data = io.BytesIO(response.content)
file_type = file.name.split(".")[-1]
return data, file_type
class TransportAuth(Transport):
"""
Authenticated Transport instance object base
"""
class Meta:
verbose_name = 'Auth Transport'
username = models.CharField(
default="",
help_text="Authentication Username",
max_length=30,
blank=True
)
password = EncryptedCharField(
default="",
help_text="Authentication password",
max_length=50,
blank=True
)
ca_cert = EncryptedTextField(
default="",
help_text="CA Certificate",
blank=True
)
client_cert = EncryptedTextField(
default="",
help_text="Client Certificate",
blank=True
)
client_key = EncryptedTextField(
default="",
help_text="Client Key",
blank=True
)
def etcd_data(self):
return {
'username': self.username,
'password': to_str(settings.CRYPTO.encrypt(to_bytes(self.password))),
'ca_cert': to_str(settings.CRYPTO.encrypt(to_bytes(self.ca_cert))),
'client_cert': to_str(settings.CRYPTO.encrypt(to_bytes(self.client_cert))),
'client_key': to_str(settings.CRYPTO.encrypt(to_bytes(self.client_key)))
}
class Manager(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=256)
fqdn = models.CharField(max_length=256)
url = models.CharField(max_length=512)
username = models.CharField(max_length=64)
password = EncryptedTextField()
version = models.CharField(max_length=16)
discovered = models.DateTimeField(editable=False)
updated = models.DateTimeField()
class Project(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True)
name = models.CharField(max_length=100, null=False, unique=True)
password = EncryptedTextField(max_length=40, null=False)
contractor_email = models.CharField(max_length=100, null=False)
description = models.TextField(default="no description")
# location = models.PointField()
date_posted = models.DateTimeField(default=timezone.now)
def __str__(self):
return "{} - {}".format(self.name, self.contractor_email)
class Wallet(models.Model):
user = models.OneToOneField(TwoFAUser,
on_delete=models.CASCADE,
related_name="wallet_user")
private_key = EncryptedTextField(null=True)
balance = models.DecimalField(max_digits=10,
decimal_places=2,
default=0.00)
def __str__(self):
return f"{self.id} : {self.user} - ${self.balance}"
class Contract(models.Model):
user = models.ForeignKey(TwoFAUser,
on_delete=models.CASCADE,
related_name="merchant_user")
merchant = models.ForeignKey(TwoFAUser,
on_delete=models.CASCADE,
related_name="merchant")
shared_key = EncryptedTextField(null=True)
sign_date = models.DateTimeField(default=datetime.now, blank=True)
def __str__(self):
return f"{self.user} : {self.merchant}"
class MyEncrypt(models.Model):
username = models.CharField(max_length=10)
name = models.CharField(max_length=200)
memo = models.CharField(max_length=200)
seed = EncryptedTextField()
pub_date = models.DateTimeField('date updated')
def __str__(self):
return self.username
def show_seed(self):
return self.seed
class ContactList(models.Model):
user = models.ForeignKey(TwoFAUser,
on_delete=models.CASCADE,
related_name="contract_user")
person = models.ForeignKey(TwoFAUser,
on_delete=models.CASCADE,
related_name="person")
shared_key = EncryptedTextField()
created_date = models.DateTimeField(auto_now_add=True, auto_now=False)
def __str__(self):
return f"{self.id} : {self.user}"
class Card(models.Model):
id = models.AutoField(primary_key=True)
#data = models.BinaryField(unique=True)
data = EncryptedTextField()
product = models.ForeignKey('LegacySite.Product',
on_delete=models.CASCADE,
default=None)
amount = models.IntegerField()
#amount = EncryptedTextField()
fp = models.CharField(max_length=100, unique=True)
user = models.ForeignKey('LegacySite.User', on_delete=models.CASCADE)
#user = EncryptedTextField()
used = models.BooleanField(default=False)
class DropboxDatalake(models.Model):
username = models.CharField(max_length=100)
root_path = models.CharField(max_length=500, default="", blank=True)
token_cache = EncryptedTextField()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.service = util.get_service_from_cache(json.loads(
self.token_cache))
self.path = f"/{self.root_path}/" if self.root_path else "/"
def __str__(self):
return f"{self.username} (Dropbox)"
def list_objects(self, path):
search_results = self.service.files_list_folder(f"{self.path}{path}")
return [entry.name for entry in search_results.entries]
def create_folder(self, path, folder_name):
full_path = folder_name
if path:
full_path = f"{path}/{full_path}"
self.service.files_create_folder_v2(f"{self.path}{full_path}")
logger.info(f"Created folder '{folder_name}' in {self}.")
def delete_path(self, path):
self.service.files_delete_v2(f"{self.path}{path}".rstrip("/"))
logger.info(f"Deleted path '{path}' in {self}.")
def upload_file(self, path, filename, content):
if isinstance(content, str):
content = content.encode()
self.service.files_upload(content,
f"{self.path}{path}/{filename}",
mute=True)
logger.info(f"Uploaded '{filename}' to '{path}' in {self}.")
def download_file(self, path, query="latest"):
filename, timestamp = get_wanted_file(query, self.list_objects(path))
_, resp = self.service.files_download(f"{self.path}{path}/{filename}")
data = pd.read_parquet(io.BytesIO(resp.content)) if filename.split(
".")[-1] == "parquet" else resp.json()
logger.info(f"Downloaded '{filename}' from {self}.")
return data, timestamp
