def as_sitemap_url(self, *args, **kwargs):
     target_name = self.__target.name
     with_name = kwargs.get('with_name', target_name)
     python_formatting = kwargs.get('python_formatting', False)
     url = self.__target.as_sitemap_url(*args, **kwargs)
     for key, value in self.__presets.items():
         url = url.replace(
             ('%%(%s)s' if python_formatting else '{%s}') % key, value)
         if target_name == key and target_name != with_name:
             url = url.replace(
                 ('%%(%s)s' if python_formatting else '{%s}') % with_name,
                 value)
     return url
Ejemplo n.º 2
0
	def _format_url(self, url, parent_id = None):
		return url.replace(
			'12345', '<b>&lt;id&gt;</b>'
		).replace(
			'67890', '<b>&lt;%s&gt;</b>' % parent_id
		).replace(
			'xml', '<b>&lt;format&gt;</b>'
		)
Ejemplo n.º 3
0
    def register_model(self,
                       model,
                       viewset=None,
                       serializer=None,
                       fields=None,
                       queryset=None,
                       filter=None,
                       cache_filter=None,
                       **kwargs):
        if isinstance(model, string_types) and '.' in model:
            from django.db.models import get_model
            model = get_model(*model.split('.'))

        if viewset:
            self.register_viewset(model, viewset)
        if queryset is not None:
            self.register_queryset(model, queryset)
        if filter:
            self.register_filter(model, filter)
        if cache_filter:
            self.register_cache_filter(model, cache_filter)
            kwargs['cache'] = 'filter'

        if 'name' not in kwargs:
            kwargs['name'] = model._meta.model_name
        if 'url' not in kwargs:
            url = force_text(model._meta.verbose_name_plural)
            kwargs['url'] = url.replace(' ', '')

        other_model = self._page_models.get(kwargs['name'], None)
        if other_model:
            raise ImproperlyConfigured(
                "Could not register %s: "
                "the name '%s' was already registered for %s" %
                (model, kwargs['name'], other_model))

        other_model = self._url_models.get(kwargs['url'], None)
        if other_model:
            raise ImproperlyConfigured(
                "Could not register %s: "
                "the url '%s' was already registered for %s" %
                (model, kwargs['url'], other_model))

        self.register_config(model, kwargs)

        if serializer:
            self.register_serializer(model, serializer)

        if fields:
            self.register_fields(model, fields)

        self._models.add(model)
        self._page_names[model] = kwargs['name']
        self._page_models[kwargs['name']] = model
        self._url_models[kwargs['url']] = model
Ejemplo n.º 4
0
Archivo: routers.py Proyecto: wq/wq.db
    def register_model(self, model, viewset=None, serializer=None, fields=None,
                       queryset=None, filter=None, cache_filter=None,
                       **kwargs):
        if isinstance(model, string_types) and '.' in model:
            from django.db.models import get_model
            model = get_model(*model.split('.'))

        if viewset:
            self.register_viewset(model, viewset)
        if queryset is not None:
            self.register_queryset(model, queryset)
        if filter:
            self.register_filter(model, filter)
        if cache_filter:
            self.register_cache_filter(model, cache_filter)
            kwargs['cache'] = 'filter'

        if 'name' not in kwargs:
            kwargs['name'] = model._meta.model_name
        if 'url' not in kwargs:
            url = force_text(model._meta.verbose_name_plural)
            kwargs['url'] = url.replace(' ', '')

        other_model = self._page_models.get(kwargs['name'], None)
        if other_model:
            raise ImproperlyConfigured(
                "Could not register %s: "
                "the name '%s' was already registered for %s"
                % (model, kwargs['name'], other_model)
            )

        other_model = self._url_models.get(kwargs['url'], None)
        if other_model:
            raise ImproperlyConfigured(
                "Could not register %s: "
                "the url '%s' was already registered for %s"
                % (model, kwargs['url'], other_model)
            )

        self.register_config(model, kwargs)

        if serializer:
            self.register_serializer(model, serializer)

        if fields:
            self.register_fields(model, fields)

        self._models.add(model)
        self._page_names[model] = kwargs['name']
        self._page_models[kwargs['name']] = model
        self._url_models[kwargs['url']] = model
Ejemplo n.º 5
0
def docs_define(url,
                params=None,
                headers=None,
                desc='',
                name=None,
                display=True):
    """
    :param name: name of reverse generation url
        >>> from django.urls import reverse
        >>> reverse(name)
    :param url: api url
    :param params: request body content
    :param headers: request header content
    :param desc: API description
    :param display: display on the document
    :return:
    """

    if not name:
        name = url.replace('/', '_').strip('_')
    docs_params = settings.DJANGO_DOCS_GLOBAL_PARAMS
    docs_headers = settings.DJANGO_DOCS_GLOBAL_HEADERS

    if params:
        docs_params.extend(list(params))
    if headers:
        docs_headers.extend(list(headers))
    docs_params = check_param(docs_params)
    docs_headers = check_param(docs_headers)

    def decorator(view):
        method = view.__name__
        router.register(view=view,
                        name=name,
                        url=url,
                        params=docs_params,
                        headers=docs_headers,
                        desc=desc,
                        method=method,
                        display=display)

        @functools.wraps(view)
        def handler(*args, **kwargs):
            return view(*args, **kwargs)

        return handler

    return decorator
Ejemplo n.º 6
0
def urls_to_html(urls, reverse=True, target="_blank", hide_protocol=True, classname=None, divider="<br />"):
    if not urls:
        return urls
    urls = [
        u'<a %shref="%s" %s/>%s</a>' % (
            ('target="%s" ' % target) if target else "",
            url,
            ('class="%s" ' % classname) if classname else "",
            (url.replace('https://', '').replace('http://', '')
             if hide_protocol else url).strip('/')
        ) for url in urls
    ]
    if reverse:
        urls.reverse()
    html = divider.join(urls)
    return html
Ejemplo n.º 7
0
    def register_model(self, model, viewset=None, serializer=None,
                       queryset=None, filter=None, **kwargs):
        if isinstance(model, basestring) and '.' in model:
            from django.db.models import get_model
            model = get_model(*model.split('.'))
        self._models.add(model)
        ct = get_ct(model)

        if viewset:
            self.register_viewset(model, viewset)
        if serializer:
            self.register_serializer(model, serializer)
        if queryset:
            self.register_queryset(model, queryset)
        if filter:
            self.register_filter(model, filter)

        if 'name' not in kwargs:
            kwargs['name'] = ct.identifier
        if 'url' not in kwargs:
            url = unicode(model._meta.verbose_name_plural)
            kwargs['url'] = url.replace(' ', '')

        self.register_config(model, kwargs)
Ejemplo n.º 8
0
def upload_album(request):
    """ Allow the artist to upload an album to the store. """

    # Only needed to fill in currency info
    store = request.user.get_default_store()

    # if request.get_host() == "libertymusicstore.net":
    # upload_url = "https://upload.libertymusicstore.net" if "libertymusicstore.net" in request.get_host() else ""
    #
    logger.info("Processing")


    if request.method == "POST":
        logger.info("Got POST")
        form = AlbumUploadForm(request.POST, request.FILES, request=request)
        if form.is_valid():
            try:

                store = form.cleaned_data["store"]

                upload = form.cleaned_data["zip_file"]

                album = zipupload.upload_album(store,
                                               form.cleaned_data["album_name"],
                                               upload,
                                               form.cleaned_data["album_price"],
                                               form.cleaned_data["song_price"],
                                               )

                try:
                    album.genre = int(form.cleaned_data["genre"])
                except ValueError:
                    album.genre = None

                album.store = form.cleaned_data["store"]
                album.description = form.cleaned_data["description"][0:40]
                album.save()

                messages.success(request, "The album is now uploaded. It might still take couple of minutes to process all songs and have them to appear.")

                # Succesfully loaded embed from the user website
                # TODO: Make sure we are the store owner
                wizard = models.WelcomeWizard(store)
                wizard.set_step_status("upload_album", True)

                # JavaScript redirect to this URL
                url = reverse('admin:tatianastore_album_change', args=(album.id,))
                url = url.replace("upload.libertystoremusic.net", "libertystoremusic.net")
                return http.HttpResponse(url)
            except zipupload.BadAlbumContenException as e:
                # Handle b(ad upload content errors
                logger.error("Bad album content")
                logger.exception(e)
                errors = form._errors.setdefault("zip_upload", ErrorList())
                errors.append(str(e))
                return http.HttpResponseServerError(str(e))
    else:
        logger.info("Not a POST request to upload album")
        form = AlbumUploadForm(request=request)

    form.fields["song_price"].label = "Song price for individual buys ({})".format(store.currency)
    form.fields["album_price"].label = "Album price ({})".format(store.currency)

    # Workaround for 100mb cloudflare upload limit
    logger.info("Upload host set to %s", request.get_host())
    upload_url = "https://upload.libertymusicstore.net/storeadmin/upload-album/" if "libertymusicstore.net" in request.get_host() else ""

    return render_to_response("storeadmin/upload_album.html", locals(), context_instance=RequestContext(request))
Ejemplo n.º 9
0
 def _format_url(self, url, parent_id=None):
     return url.replace('12345', '<b>&lt;id&gt;</b>').replace(
         '67890',
         '<b>&lt;%s&gt;</b>' % parent_id).replace('xml',
                                                  '<b>&lt;format&gt;</b>')
Ejemplo n.º 10
0
def get_mapproxy(layer, seed=False, ignore_warnings=True, renderd=False):
    """Creates a mapproxy config for a given layer-like object.
       Compatible with django-registry and GeoNode.
    """
    bbox = list(wkt2geom(layer.wkt_geometry))

    # TODO: Check for correct url
    url = 'http://test.registry.org'
    # url = str(layer.service.url)

    layer_name = str(layer.title)

    srs = 'EPSG:4326'
    bbox_srs = 'EPSG:4326'
    grid_srs = 'EPSG:3857'

    default_source = {
        'type': 'wms',
        'coverage': {
            'bbox': bbox,
            'srs': srs,
            'bbox_srs': bbox_srs,
            'supported_srs': ['EPSG:4326', 'EPSG:900913', 'EPSG:3857'],
        },
        'req': {
            'layers': str(layer.title),
            'url': url,
            'transparent': True,
        },
    }

    if layer.type == 'ESRI:ArcGIS:MapServer' or layer.type == 'ESRI:ArcGIS:ImageServer':
        # blindly replace it with /arcgis/
        url = url.replace("/ArcGIS/rest/", "/arcgis/")
        # same for uppercase
        url = url.replace("/arcgis/rest/", "/arcgis/")
        # and for old versions
        url = url.replace("ArcX/rest/services", "arcx/services")
        # in uppercase or lowercase
        url = url.replace("arcx/rest/services", "arcx/services")

        srs = 'EPSG:3857'
        bbox_srs = 'EPSG:3857'

        default_source = {
            'type': 'arcgis',
            'req': {
                'url': url,
                'grid': 'default_grid',
                'transparent': True,
            },
        }

    # A source is the WMS config
    sources = {'default_source': default_source}

    # A grid is where it will be projects (Mercator in our case)
    grids = {
        'default_grid': {
            'tile_size': [256, 256],
            'srs': grid_srs,
            'origin': 'nw',
        }
    }

    # A cache that does not store for now. It needs a grid and a source.
    caches = {
        'default_cache': {
            'disable_storage': True,
            'grids': ['default_grid'],
            'sources': ['default_source']
        },
    }

    # The layer is connected to the cache
    layers = [
        {
            'name': layer_name,
            'sources': ['default_cache'],
            'title': str(layer.title),
        },
    ]

    # Services expose all layers.
    # WMS is used for reprojecting
    # TMS is used for easy tiles
    # Demo is used to test our installation, may be disabled in final version
    services = {
        'wms': {
            'image_formats': ['image/png'],
            'md': {
                'abstract': 'This is the Harvard HyperMap Proxy.',
                'title': 'Harvard HyperMap Proxy'
            },
            'srs': ['EPSG:4326', 'EPSG:3857'],
            'versions': ['1.1.1']
        },
        'wmts': {
            'restful':
            True,
            'restful_template':
            '/{Layer}/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png',
        },
        'tms': {
            'origin': 'nw',
        },
        'demo': None,
    }

    global_config = {
        'http': {
            'ssl_no_cert_checks': True
        },
    }

    # Start with a sane configuration using MapProxy's defaults
    conf_options = load_default_config()

    # Populate a dictionary with custom config changes
    extra_config = {
        'caches': caches,
        'grids': grids,
        'layers': layers,
        'services': services,
        'sources': sources,
        'globals': global_config,
    }

    yaml_config = yaml.dump(extra_config, default_flow_style=False)
    # If you want to test the resulting configuration. Turn on the next
    # line and use that to generate a yaml config.
    # assert False

    # Merge both
    load_config(conf_options, config_dict=extra_config)

    # TODO: Make sure the config is valid.
    errors, informal_only = validate_options(conf_options)
    for error in errors:
        LOGGER.warn(error)
    if not informal_only or (errors and not ignore_warnings):
        raise ConfigurationError('invalid configuration')

    errors = validate_references(conf_options)
    for error in errors:
        LOGGER.warn(error)

    conf = ProxyConfiguration(conf_options, seed=seed, renderd=renderd)

    # Create a MapProxy App
    app = MapProxyApp(conf.configured_services(), conf.base_config)

    return app, yaml_config
Ejemplo n.º 11
0
def uuidzy(url):
    return url.replace('%u', '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
Ejemplo n.º 12
0
def get_mapproxy(layer,
                 seed=False,
                 ignore_warnings=True,
                 renderd=False,
                 config_as_yaml=True):
    """Creates a mapproxy config for a given layer-like object.
       Compatible with django-registry and GeoNode.
    """
    bbox = list(wkt2geom(layer.wkt_geometry))
    bbox = ",".join([format(x, '.4f') for x in bbox])
    url = str(layer.source)

    layer_name = str(layer.title)

    srs = 'EPSG:4326'
    bbox_srs = 'EPSG:4326'
    grid_srs = 'EPSG:3857'

    default_source = {
        'type': 'wms',
        'coverage': {
            'bbox': bbox,
            'srs': srs,
            'bbox_srs': bbox_srs,
            'supported_srs': ['EPSG:4326', 'EPSG:900913', 'EPSG:3857'],
        },
        'req': {
            'layers': str(layer.title),
            'url': url,
            'transparent': True,
        },
    }

    if layer.type == 'ESRI:ArcGIS:MapServer' or layer.type == 'ESRI:ArcGIS:ImageServer':
        # blindly replace it with /arcgis/
        url = url.replace("/ArcGIS/rest/", "/arcgis/")
        # same for uppercase
        url = url.replace("/arcgis/rest/", "/arcgis/")
        # and for old versions
        url = url.replace("ArcX/rest/services", "arcx/services")
        # in uppercase or lowercase
        url = url.replace("arcx/rest/services", "arcx/services")

        srs = 'EPSG:3857'
        bbox_srs = 'EPSG:4326'

        default_source = {
            'type': 'arcgis',
            'req': {
                'url': url.split('?')[0],
                'grid': 'default_grid',
                'transparent': True,
            },
        }

    # A source is the WMS config
    sources = {'default_source': default_source}

    # A grid is where it will be projects (Mercator in our case)
    grids = {
        'default_grid': {
            'tile_size': [256, 256],
            'srs': grid_srs,
            'origin': 'nw',
        }
    }

    # A cache that does not store for now. It needs a grid and a source.
    caches = {
        'default_cache': {
            'disable_storage': True,
            'grids': ['default_grid'],
            'sources': ['default_source']
        },
    }

    # The layer is connected to the cache
    layers = [
        {
            'name': layer_name,
            'sources': ['default_cache'],
            'title': "%s" % layer.title,
        },
    ]

    # Services expose all layers.
    # WMS is used for reprojecting
    # TMS is used for easy tiles
    # Demo is used to test our installation, may be disabled in final version
    services = {
        'wms': {
            'image_formats': ['image/png'],
            'md': {
                'abstract': 'This is the Harvard HyperMap Proxy.',
                'title': 'Harvard HyperMap Proxy'
            },
            'srs': ['EPSG:4326', 'EPSG:3857'],
            'srs_bbox': 'EPSG:4326',
            'bbox': bbox,
            'versions': ['1.1.1']
        },
        'wmts': {
            'restful':
            True,
            'restful_template':
            '/{Layer}/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png',
        },
        'tms': {
            'origin': 'nw',
        },
        'demo': None,
    }

    global_config = {
        'http': {
            'ssl_no_cert_checks': True
        },
    }

    # Populate a dictionary with custom config changes
    extra_config = {
        'caches': caches,
        'grids': grids,
        'layers': layers,
        'services': services,
        'sources': sources,
        'globals': global_config,
    }

    yaml_config = yaml.dump(extra_config, default_flow_style=False)
    # If you want to test the resulting configuration. Turn on the next
    # line and use that to generate a yaml config.
    # assert False

    conf = configure_mapproxy(extra_config)
    # Create a MapProxy App
    app = MapProxyApp(conf.configured_services(), conf.base_config)

    # Wrap it in an object that allows to get requests by path as a string.
    if (config_as_yaml):
        return app, yaml_config

    return app, extra_config
Ejemplo n.º 13
0
def handle_image_from_xhr_upload(request, instance, attr_name):
    inicio = time_module.time()
    if attr_name in request.FILES:
        image_file = request.FILES[attr_name]
        img_name = image_file.name
    
    elif 'url' in request.POST: # If image comes from url
        url = request.POST['url']
        url = url.replace(" ", "%20")
        imgcontent = urllib.urlopen(url) # open the image contents
        image_file = StringIO(imgcontent.read()) # creates an in memory file object
        
        parsed_url = urlparse(url)
        img_name = parsed_url.path # gets the file name on url
    
    extension = img_name[img_name.rfind("."):] # gets the image extension
    
    # gets the ImageCrop attribute from the model
    image_crop_attr_obj = getattr(instance, attr_name) 
    
    upload_to = image_crop_attr_obj.field.upload_to
    time = int(datetime.now().microsecond)# current time to add on the file name
    
    # Open the uploaded (or downloaded in case it's from url) image
    image_file = Image.open(image_file)
    img_attr_obj = getattr(instance, attr_name)
    
    try:
        os.remove(img_attr_obj.path)
    except:
        pass
    
    try:
        last_original_path = img_attr_obj.path
        last_slash = last_original_path.rfind("/")
        
        if last_slash == -1:
            last_slash = last_original_path.rfind("\\")
        
        last_original_name = last_original_path[last_slash+1:]
        last_original_name = last_original_name.replace(attr_name, 
                                                        attr_name+"_original")
        
        os.remove(os.path.join(settings.MEDIA_ROOT, upload_to, last_original_name))
    except:
        pass
        
    ready_image_file = None
    ready_image_file = StringIO()
    image_file.save(ready_image_file , 'PNG', optimize = True)
    ready_image_file.seek(0)
    
    # Set the uploaded image to the file attribute of the imagefield
    img_attr_obj.file = ready_image_file
    
    # Seta o novo nome da imagem upada para o campo atual da iteracao (upload_to/nome.jpg)
    image_original_name = "%s%s_original_%s_%s%s" % (upload_to, attr_name, instance.id, time, extension)
    
    img_attr_obj.name = "%s%s_%s_%s%s" % (upload_to, attr_name, instance.id, time, extension)
    
    # Abre e salva a imagem atual no sistema de arquivos
    image_obj = Image.open( img_attr_obj )
    
    #image_obj.
    image_obj.save( img_attr_obj.path )
    
    # Dimensoes para usar como parametro na funcao adjust_img()
    dim = img_attr_obj.field.dimensions
    
    # Cria uma imagem cropavel ajustada para o tamanho especificado para o campo atual
    adjusted_image = adjust_img(img_attr_obj.path, dim[0], dim[1], dim[0], dim[1])
    adjusted_image.save( os.path.join(settings.MEDIA_ROOT,image_original_name))
    original_img_dim = adjusted_image.size
    
    box = getBox(adjusted_image, dim[0], dim[1])
    
    cropped_img = adjusted_image.crop(box)
    
    # Salva a imagem cropada no lugar da anterior (a imagem upada não tratada)
    cropped_img.save( img_attr_obj.path )
    cropped_img_dim = cropped_img.size
    
    instance.save()
    
    data = serializers.serialize("json", [instance])
    
    json_as_python = json.loads(data)
    
    original_dict_key = {
        attr_name+'_original': {
            'src':os.path.join("/media/", image_original_name),
            'dimensions':"%i,%i"%(original_img_dim[0], original_img_dim[1]),
        }
    }
    
    cropped_imgage = {
        attr_name+'_cropped': {
            'src': os.path.join("/media/", img_attr_obj.name),
            'dimensions':"%i,%i"%(cropped_img_dim[0], cropped_img_dim[1]),
        }
    }
    
    json_as_python[0].update(original_dict_key)
    json_as_python[0].update(cropped_imgage)
    
    data = json.dumps(json_as_python)
    return data