def uris(self):
return URIs(media=uri("media", {
"id": self.media_name,
"extension": self.extension
}),
preview=uri("preview", {
"id": self.media_name,
"extension": self.extension
}))
async def post(self):
user = self.current_user
if not 'file' in self.request.files.keys():
self.write({"Error": "File not provided"})
self.set_status(422)
return
image = self.request.files['file'][0]
# Search for a valid id
valid = False
ident = ""
while not valid:
try:
ident = str(uuid.uuid4())
media = await self.application.objects.get(Media, media_name = ident)
except Media.DoesNotExist:
valid = True # If we are here that means that the object exits
manager = MediaManager(self.request.files['file'][0]['body'])
valid = manager.is_valid()
if valid:
description = self.get_argument('description', '')
focus = (0,0)
if self.get_argument('focus', False):
args = self.get_argument('focus').replace(" ", "").split(',')
if len(args) == 2:
focus = args[:2]
extension = manager.get_media_type()
urls = URIs(
media=uri("media", {"id":ident, "extension": extension}),
preview=uri("preview", {"id":ident, "extension": extension})
)
m = {
"description": description,
"id": ident,
"type": "unknown",
"url": urls.media,
"preview_url": urls.preview,
"meta": None
}
store_media(manager, ident, description, focus)
self.write(json.dumps(m, default=str))
self.set_status(200)
else:
raise CustomError(reason="Error storing files", status_code=400)
def uris(self):
if self.remote:
ap_id = self.ap_id
else:
ap_id = uri("status", {
"username": self.user.username,
"id": self.id
})
return URIs(id=ap_id,
media=uri("media", {"id": self.media_name}),
preview=uri("preview", {"id": self.media_name}))
def uris(self):
from models.media import Media
if self.remote:
ap_id = self.ap_id
else:
ap_id = uri("status", {"username":self.user.username, "id":self.id})
return URIs(id=ap_id,
url = uri("status_client_url", {"username": self.user.username, "id": self.id }),
media=[uri.uris.media for uri in self.media_object],
preview=[uri.uris.preview for uri in self.media_object]
)
async def to_activitystream(self):
uris = await self.uris
json_dict = {
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://w3id.org/security/v1",
],
"type": "Person",
"id": uris.id,
"name": self.name,
"preferredUsername": await self.username,
}
if not self.is_remote:
json_dict.update({
"following": uris.following,
"followers": uris.followers,
"outbox": uris.outbox,
"inbox": uris.inbox,
"publicKey": {
'publicKeyPem': import_keys()["actorKeys"]["publicKey"],
'id': f'{BASE_URL}/users/{await self.username}#main-key',
'owner': f'{BASE_URL}/users/{await self.username}'
},
"summary": self.description,
"manuallyApprovesFollowers": await self.is_private,
"featured": uris.featured,
"endpoints": {
"sharedInbox": uri('sharedInbox')
}
})
return json_dict
async def to_activitystream(self):
await self.fetch_related('user')
media_files = await fetch_media_as_by_id(self.ident)
data = {
"id": uri("status", {"username":self.user.username, "id":self.id}),
"type": "Note",
"summary": None,
"published": self.created_at.replace(microsecond=0).isoformat() + "Z",
"url": self.uris.url,
"attributedTo": await self.user.ap_id,
#"hashtags": self.hashtags,
"sensitive": self.sensitive,
"attachment": media_files,
"spoiler_text": self.spoiler_text,
"content": self.caption,
}
if self.is_public:
data['to'] = ["https://www.w3.org/ns/activitystreams#Public"]
else:
data['to'] = []
data['cc'] = [self.user.uris.followers]
return data
def save(self,*args, **kwargs):
if not self.ap_id:
self.ap_id = uri("status", {"username":self.user.username, "id":self.id})
if not self.identifier:
self.identifier = self.generate_id()
return super(Status, self).save(*args, **kwargs)
def uris(self):
if self.remote:
ap_id = self.ap_id
else:
ap_id = uri("activity", {
"username": self.person.username,
"id": self.id
})
return URIs(id=ap_id)
def save(self, *args, **kwargs):
if not self.remote:
self.ap_id = uri("user", {"username": self.username})
if not self.private_key and not self.public_key:
#Create a pair public/private key to sign messages
random_generator = Random.new().read
key = RSA.generate(2048, random_generator)
self.public_key = key.publickey().exportKey().decode('utf-8')
self.private_key = key.exportKey().decode('utf-8')
return super(User, self).save(*args, **kwargs)
def uris(self):
if self.is_remote:
return URIs(
id=self.ap_id,
inbox=f'{self.ap_id}/inbox',
outbox=f'{self.ap_id}/inbox',
following=f'{self.ap_id}/following',
followers=f'{self.ap_id}/followers',
)
return URIs(id=uri("user", {"username": self.username}),
following=uri("following", {"username": self.username}),
followers=uri("followers", {"username": self.username}),
outbox=uri("outbox", {"username": self.username}),
inbox=uri("inbox", {"username": self.username}),
atom=uri("atom", {"id": self.id}),
featured=uri("featured", {"username": self.username}),
avatar=uri('profile_image', {"name": self.avatar_file}),
client=uri('user_client', {'username': self.username}))
def uris(self):
if self.remote:
return URIs(id=self.ap_id)
return URIs(
id=uri("user", {"username": self.username}),
following=uri("following", {"username": self.username}),
followers=uri("followers", {"username": self.username}),
outbox=uri("outbox", {"username": self.username}),
inbox=uri("inbox", {"username": self.username}),
atom=uri("atom", {"username": self.username}),
avatar=self.avatar,
featured=uri("featured", {"username": self.username}),
)
def save(self, *args, **kwargs):
if not self.is_remote:
self.ap_id = uri("user", {"username": self.username})
if not self.id:
self.id = self.user.id
if not self.avatar_file:
pixel_avatar = PixelAvatar(rows=10, columns=10)
image_byte_array = pixel_avatar.get_image(size=400,
string=self.ap_id,
filetype="jpeg")
self.avatar_file = self._crate_avatar_file(image_byte_array)
return super(UserProfile, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
if not self.remote:
self.ap_id = uri("user", {"username": self.username})
if not self.private_key and not self.public_key:
#Create a pair public/private key to sign messages
random_generator = Random.new().read
key = RSA.generate(2048, random_generator)
self.public_key = key.publickey().exportKey().decode('utf-8')
self.private_key = key.exportKey().decode('utf-8')
if not self.avatar_file:
pixel_avatar = PixelAvatar(rows=10, columns=10)
image_byte_array = pixel_avatar.get_image(size=400,
string=self.ap_id,
filetype="jpeg")
self.avatar_file = self._crate_avatar_file(image_byte_array)
return super(UserProfile, self).save(*args, **kwargs)
def to_activitystream(self):
json = {
"id": uri("status", {"username":self.user.username, "id":self.id}),
"type": "Note",
"summary": None,
"published": self.created_at.replace(microsecond=0).isoformat() + "Z",
"url": self.uris.url,
"attributedTo": self.user.ap_id,
#"hashtags": self.hashtags,
"sensitive": self.sensitive,
"attachment":[ media.to_activitystream() for media in self.media_object],
"spoiler_text": self.spoiler_text,
"content": self.caption,
}
if self.is_public:
json['to'] = ["https://www.w3.org/ns/activitystreams#Public"]
else:
json['to'] = []
json['cc'] = [self.user.uris.followers]
return json
async def new_user_async(
username: str,
password: str,
email: str,
is_remote: bool = False,
confirmed: bool = False,
is_private: bool = False,
is_admin: bool = False,
public_key: str = None,
name: str = None,
description: str = "",
ap_id: str = None,
send_confirmation: bool = True,
public_inbox: Union[str, None] = None) -> Union[bool, UserProfile]:
"""
Returns False or UserProfile
"""
if not (password and username and email):
return False
objects = Manager(db)
# Verify username
logging.debug(f"Starting to create user {username}")
username_count = await objects.count(
User.select().where(User.username == username))
if not valid_username(username) or (username_count != 0):
logger.error(f"@{username} is a not valid username")
return False
# Hash the password
passw = bcrypt.hashpw(password, salt_code)
# First we create the actual user
try:
user = await objects.create(
User,
username=username.lower(),
password=passw,
email=email,
confirmed=confirmed,
is_admin=is_admin,
is_private=is_private,
)
except Exception as e:
logging.error(f"User not created: {e}")
return False
logging.debug(f"Created user {user.username}")
if name == None:
name = username
# Now we create the profile
try:
data = {
"id": user.id,
"disabled": True,
"is_remote": is_remote,
"user": user,
"name": name,
"public_key": public_key,
"description": description,
'public_inbox': public_inbox
}
if is_remote:
data['ap_id'] = ap_id
else:
data['ap_id'] = uri("user", {"username": username})
profile = await objects.create(UserProfile, **data)
# Send the confirmation email
if not user.confirmed and send_confirmation:
send_activation_email(profile)
logging.info(f"New Profile created: {profile}")
return profile
except Exception as e:
logging.error(e)
await objects.delete(user)
return False
def avatar(self):
return uri("profile_image", {"name": self.avatar_file})
def uris(self):
return URIs(media=uri("media", {"id": self.media_name}),
preview=uri("preview", {"id": self.media_name}))
