def post(self): """ Removes any existing timeout for one or more existing assets making the assets persistent. """ assets = self.get_assets(projection={'uid': True}) # Clear the expires timestamp (if there is one) for the assets Asset.get_collection().update(In(Q._id, [a._id for a in assets]).to_dict(), { '$set': { 'modified': datetime.utcnow() }, '$unset': { 'expires': '' } }, multi=True) self.write( {'results': [{ 'uid': a.uid, 'expires': None } for a in assets]})
def delete_document(state): Asset.get_collection().update_many( (Q.account == state.account._id).to_dict(), { '$set': { 'expires': time.time() - 1, 'modified': datetime.utcnow() } } ) generic.delete['post'].super(state)
def post(self): """ Removes any existing timeout for one or more existing assets making the assets persistent. Set a timeout for one or more assets. After the timeout has expired the assets will be automatically deleted. NOTE: The files associated with expired assets are delete periodically and therefore may still temporarily be available after the asset has expired and is not longer available via the API. """ assets = self.get_assets(projection={'uid': True}) # Validate the arguments form = ExpireForm(to_multi_dict(self.request.body_arguments)) if not form.validate(): raise APIError( 'invalid_request', arg_errors=form.errors ) form_data = form.data # Update the expires timestamp for the asset expires = time.time() + form_data['seconds'] Asset.get_collection().update( In(Q._id, [a._id for a in assets]).to_dict(), { '$set': { 'expires': time.time() + form_data['seconds'], 'modified': datetime.utcnow() } }, multi=True ) self.write({ 'results': [ { 'uid': a.uid, 'expires': expires } for a in assets ] })
def post(self, uid): """ Removes any existing timeout for an asset making the asset persistent. """ asset = self.get_asset(uid, projection={'uid': True, 'expires': True}) # Clear the expires timestamp (if there is one) Asset.get_collection().update({'_id': asset._id}, { '$set': { 'modified': datetime.utcnow() }, '$unset': { 'expires': '' } }) self.write({'uid': asset.uid, 'expires': None})
def _add_to_meta(self, asset, data): """Add the specified data to the asset's meta""" # Modify the asset instance if self.asset_type not in asset.meta: asset.meta[self.asset_type] = {} asset.meta[self.asset_type][self.name] = data asset.modified = datetime.utcnow() # Apply the updated to the database Asset.get_collection().update( (Q._id == asset._id).to_dict(), { '$set': { f'meta.{self.asset_type}.{self.name}': data, 'modified': asset.modified } } )
async def delete(self, uid, variation_name): """Remove the variation from the asset""" asset = self.get_asset(uid, projection={ 'expires': True, 'name': True, 'secure': True, 'uid': True, f'variations.{variation_name}': { '$sub': Variation } }) variation = self.get_variation(asset, variation_name) # Remove file for the variation backend = self.get_backend(asset.secure) await backend.async_delete(variation.get_store_key( asset, variation_name), loop=asyncio.get_event_loop()) # Remove the variation from the asset Asset.get_collection().update( (Q._id == asset._id).to_dict(), {'$unset': { f'variations.{variation_name}': '' }}) # Update the asset stats Stats.inc(self.account, today_tz(tz=self.config['TIMEZONE']), { 'variations': -1, 'length': -variation.meta['length'] }) self.set_status(204) self.finish()
def _store_variation( self, config, asset, variation_name, versioned, ext, meta, file ): """ Store a new variation of the asset. This method both stores the variation (and removes any existing variation with the same name) as well as updating the asset's `variations` field with details of the new variation. """ # Get the account and backend associated with the asset account = Account.by_id( asset.account, projection={ 'public_backend_settings': True, 'secure_backend_settings': True } ) if asset.secure: backend = account.secure_backend else: backend = account.public_backend assert backend, 'No backend configured for the asset' # Ensure the asset's variation value is a dictionary (in case it's # never been set before). if not asset.variations: asset.variations = {} # Create the new variation old_variation = asset.variations.get(variation_name) new_variation = Variation( content_type=mimetypes.guess_type(f'f.{ext}')[0] if ext else '', ext=ext, meta=meta, version=( Variation.next_version( old_variation.version if old_variation else None ) if versioned else None ) ) # Store the new variation new_store_key = new_variation.get_store_key(asset, variation_name) file.seek(0) backend.store(file, new_store_key) # Add the new variation's details to the asset's `variations` field asset.variations[variation_name] = new_variation asset.modified = datetime.utcnow() # Apply the updated to the database Asset.get_collection().update( (Q._id == asset._id).to_dict(), { '$set': { f'variations.{variation_name}': \ new_variation.to_json_type(), 'modified': asset.modified } } ) # Remove the existing variation if old_variation: old_store_key = old_variation.get_store_key(asset, variation_name) if new_store_key != old_store_key: backend.delete(old_store_key) # Update the asset stats new_length = new_variation.meta['length'] old_length = 0 if old_variation: old_length = old_variation.meta['length'] Stats.inc( account, today_tz(tz=config['TIMEZONE']), { 'variations': 0 if old_variation else 1, 'length': new_length - old_length } )