Exemple #1
0
class Identifier:
    '''
    Provides the gateway identifier.        
        Clients -   contains the client IPs or names regexes that needs to match in order to validate the gateway, if
                    none is provided then the gateway applies to all. At least one client IP needs to match to consider
                    the navigation valid.
        Pattern -   contains the regex that needs to match with the requested URI. The pattern needs to produce, if is the
                    case, capturing groups that can be used by the Filters or Navigate.
        Headers -   The headers to be filtered in order to validate the navigation. The headers are provided as regexes that
                    need to be matched. In case of headers that are paired as name and value the regex will receive the matching
                    string as 'Name:Value', the name is not allowed to contain ':'. At least one header needs to match to consider
                    the navigation valid.
        Methods -   The list of allowed methods for the request, if no method is provided then all methods are considered
                    valid. At least one method needs to match to consider the navigation valid.
        Errors -    The list of errors codes that are considered to be handled by this Gateway entry, if no error is provided
                    then it means the entry is not solving any error navigation. At least one error needs to match in order
                    to consider the navigation valid. The gateways that solve errors will receive also parameters for error
                        status - the status code of the error
                        allow - the method name(s) allowed, this will be provided in case of status 405 (Method not allowed)
    '''
    # The request identification attributes
    Clients = List(str)
    Pattern = str
    Headers = List(str)
    Methods = List(str)
    Errors = List(int)
Exemple #2
0
class Gateway(Identifier):
    '''
    Provides the gateway.
        Filters -   contains a list of URIs that need to be called in order to allow the gateway Navigate. The filters
                    are provided as 'group:URI' where group is a number from 1 to n where n is the number of capture 
                    groups  obtained from the Pattern, the filter URI is allowed to have place holders of form '*'
                    where the provided group value will be injected. In order to validate navigation at least one filter
                    from the each group will have to return an allowed access, also pre populated parameters are allowed
                    for filter URI.
        Host -      The host where the request needs to be resolved, if not provided the request will be delegated to the
                    default host.
        Protocol -  The protocol to be used in the communication with the server that handles the request, if not provided
                    the request will be delegated using the default protocol.
        Navigate -  A pattern like string of forms like '*', 'resources/*' or 'redirect/Model/{1}'. The pattern is allowed to
                    have place holders and also the '*' which stands for the actual called URI, also parameters are allowed
                    for navigate URI, the parameters will be appended to the actual parameters.
        PutHeaders -The headers to be put on the forwarded requests.
        Exclude -   The list of index block names to be excluded from the response.
    '''
    # The navigation attributes
    Filters = List(str)
    Host = str
    Protocol = str
    Navigate = str
    PutHeaders = Dict(str, str)
    # The response attributes
    Exclude = List(str)
Exemple #3
0
class Perform:
    '''
    Provides the perform of an action, as defined in @see: ally.indexing.spec.model.Perform
    '''
    Id = int
    Verb = str
    Flags = List(str)
    Index = str
    Key = str
    Name = str
    Value = str
    Actions = List(str)
    Escapes = Dict(str, str)
Exemple #4
0
class Block:
    '''
    Provides the index block, as defined in @see: ally.indexing.spec.model.Block
    '''
    Id = int
    Name = str
    Keys = List(str)
Exemple #5
0
class Action:
    '''
    Provides the action of a block, as defined in @see: ally.indexing.spec.model.Action
    '''
    Id = int
    Name = str
    Before = List(str)
    Final = bool
    Rewind = bool
Exemple #6
0
class Message(Entity):
    '''
    Model for a localized message.
    '''
    Source = Source
    Singular = str
    Plural = List(str)
    Context = str
    LineNumber = int
    Comments = str
Exemple #7
0
 def get(self,
         mainId: MainModel.Id,
         scheme: Scheme,
         locale: List(Locale),
         another: AModel.Key = None,
         q: QMainModel = None,
         qa: QAModel = None,
         offset: int = 0,
         limit: int = None) -> MainModel:
     '''
Exemple #8
0
class AsLikeExpression:
    '''
    Provides query for properties that can be managed by a like function, this will only handle string types
    Also provides the boolean expression functionality, that in case of like string operator can had in the same all conditions

    inc - include - means that the value is mandatory for the given criteria
    ext - extend - means that the value is optional for the given criteria
    exc - exclude - means that the value if forbidden for the given criteria

    The query compose an 'and' condition with all 'inc' criteria, and all negated 'exc' criteria. Then it is made an or with all
    'ext' criteria
    '''

    #include - the list of included values
    inc = List(str)
    #extend - the list of extended values
    ext = List(str)
    #exclude - the list of excluded values
    exc = List(str)
Exemple #9
0
class URLInfo:
    '''
    Provides the URL info model.
    '''
    URL = Reference
    ContentType = str
    Title = str
    Description = str
    SiteIcon = str
    Date = datetime
    Picture = List(Reference)
Exemple #10
0
class GatewayHTTP:
    '''
    Provides the gateway data.
        Pattern -   contains the regex that needs to match with the requested URI. The pattern needs to produce, if is the
                    case, capturing groups that can be used by the Filters or Navigate.
        Headers -   The headers to be filtered in order to validate the navigation. The headers are provided as regexes that
                    need to be matched. In case of headers that are paired as name and value the regex will receive the matching
                    string as 'Name:Value', the name is not allowed to contain ':'. At least one header needs to match to consider
                    the navigation valid.
        Methods -   The list of allowed methods for the request, if no method is provided then all methods are considered
                    valid. At least one method needs to match to consider the navigation valid.
        Filters -   contains a list of URIs that need to be called in order to allow the gateway Navigate. The filters are
                    allowed to have place holders of form '{1}' or '{2}' ... '{n}' where n is the number of groups obtained
                    from the Pattern, the place holders will be replaced with their respective group value. All filters
                    need to return a True value in order to allow the gateway Navigate, also parameters are allowed
                    for filter URI.
        Errors -    The list of errors codes that are considered to be handled by this Gateway entry, if no error is provided
                    then it means the entry is not solving any error navigation. At least one error needs to match in order
                    to consider the navigation valid. The gateways that solve errors will receive also parameters for error
                        status - the status code of the error
                        allow - the method name(s) allowed, this will be provided in case of status 405 (Method not allowed)
        Host -      The host where the request needs to be resolved, if not provided the request will be delegated to the
                    default host.
        Protocol -  The protocol to be used in the communication with the server that handles the request, if not provided
                    the request will be delegated using the default protocol.
        Navigate -  A pattern like string of forms like '*', 'resources/*' or 'redirect/Model/{1}'. The pattern is allowed to
                    have place holders and also the '*' which stands for the actual called URI, also parameters are allowed
                    for navigate URI, the parameters will be appended to the actual parameters.
        PutHeaders -The headers to be put on the forwarded requests. The values are provided as 'Name:Value', the name is
                    not allowed to contain ':'.
    '''
    Pattern = str
    Headers = List(str)
    Methods = List(str)
    Filters = List(str)
    Errors = List(int)
    Host = str
    Protocol = str
    Navigate = str
    PutHeaders = List(str)
Exemple #11
0
    def process(self, chain, processing, create: Create,
                Decoding: DecodingOrder, Definition: DefinitionOrder,
                **keyargs):
        '''
        @see: HandlerBranching.process
        
        Create the order decode.
        '''
        assert isinstance(processing,
                          Processing), 'Invalid processing %s' % processing
        assert isinstance(create, Create), 'Invalid create %s' % create
        assert issubclass(
            Decoding, DecodingOrder), 'Invalid decoding class %s' % Decoding
        assert issubclass(
            Definition,
            DefinitionOrder), 'Invalid definition class %s' % Definition

        if not create.orderSetters: return
        # There is not order to process.

        adec, ddec = Decoding(), Decoding()
        assert isinstance(adec, DecodingOrder), 'Invalid decoding %s' % adec
        assert isinstance(ddec, DecodingOrder), 'Invalid decoding %s' % ddec

        adec.type = ddec.type = List(str)

        adec.doDecode = self.createDecode(True, create.orderSetters,
                                          create.orderPriorityGetters,
                                          create.orderPrioritySetters, adec)
        ddec.doDecode = self.createDecode(False, create.orderSetters,
                                          create.orderPriorityGetters,
                                          create.orderPrioritySetters, ddec)

        adef = Definition(enumeration=sorted(create.orderSetters.keys()))
        ddef = Definition(enumeration=sorted(create.orderSetters.keys()))

        processing.wingIn(chain,
                          True,
                          decoding=ddec,
                          definition=ddef,
                          parameter=processing.ctx.parameter(path=[NAME_DESC]))
        processing.wingIn(chain,
                          True,
                          decoding=adec,
                          definition=adef,
                          parameter=processing.ctx.parameter(path=[NAME_ASC]))
Exemple #12
0
def decorateRoot():
    resourcesRoot().get = InvokerFunction(GET, partial(rootPaths, resourcesRoot()), List(TypeClass(Path)),
                                          [], {}, 'accessible', InvokerInfo('accessible', '.', 0, ''))
Exemple #13
0
@copyright: 2012 Sourcefabric o.p.s.
@license: http://www.gnu.org/licenses/gpl-3.0.txt
@author: Gabriel Nistor

Provides the accept headers handling.
'''

from ally.api.type import List, Locale
from ally.container.ioc import injected
from ally.design.processor.attribute import optional, defines
from ally.http.impl.processor.headers.accept import RequestDecode, \
    AcceptRequestDecodeHandler

# --------------------------------------------------------------------

LIST_LOCALE = List(Locale)
# The locale list used to set as an additional argument.

# --------------------------------------------------------------------


class Request(RequestDecode):
    '''
    The request context.
    '''
    # ---------------------------------------------------------------- Optional
    argumentsOfType = optional(dict)
    # ---------------------------------------------------------------- Defined
    accLanguages = defines(list,
                           doc='''
    @rtype: list[string]
Exemple #14
0
    def testEncode(self):
        transformer = CreateEncoderHandler()
        ioc.initialize(transformer)

        resolve = Resolve(transformer.encoderFor(typeFor(ModelId)))
        render = RenderToObject()
        context = dict(render=render,
                       converter=ConverterPath(),
                       converterId=ConverterPath(),
                       normalizer=ConverterPath())

        model = ModelId()
        model.Id = 12
        render.obj = None
        resolve.request(value=model, **context).doAll()
        self.assertEqual({'Id': '12'}, render.obj)

        model.ModelKey = 'The key'
        render.obj = None
        resolve.request(value=model, **context).doAll()
        self.assertEqual({
            'Id': '12',
            'ModelKey': {
                'Key': 'The key'
            }
        }, render.obj)

        model.Name = 'Uau Name'
        model.Flags = ['1', '2', '3']
        render.obj = None
        resolve.request(value=model, **context).doAll()
        self.assertEqual(
            {
                'ModelKey': {
                    'Key': 'The key'
                },
                'Flags': {
                    'Flags': ['1', '2', '3']
                },
                'Id': '12',
                'Name': 'Uau Name'
            }, render.obj)

        transformer = CreateEncoderHandler()
        ioc.initialize(transformer)

        resolve = Resolve(transformer.encoderFor(typeFor(List(ModelId))))

        render.obj = None
        resolve.request(value=[model], **context).doAll()

        self.assertEqual(
            {
                'ModelIdList': [{
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }]
            }, render.obj)

        render.obj = None
        resolve.request(value=[model, model, model], **context)
        resolve.do()
        self.assertEqual({'ModelIdList': []}, render.obj)
        resolve.do()
        self.assertEqual(
            {
                'ModelIdList': [{
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }]
            }, render.obj)
        resolve.do()
        self.assertEqual(
            {
                'ModelIdList': [{
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }, {
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }]
            }, render.obj)
        resolve.do()
        self.assertEqual(
            {
                'ModelIdList': [{
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }, {
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }, {
                    'ModelKey': {
                        'Key': 'The key'
                    },
                    'Flags': {
                        'Flags': ['1', '2', '3']
                    },
                    'Id': '12',
                    'Name': 'Uau Name'
                }]
            }, render.obj)
        resolve.do()
        self.assertFalse(resolve.has())
Exemple #15
0
class ModelId:
    Id = int
    Name = str
    Flags = List(str)
    ModelKey = ModelKey
Exemple #16
0
 def getByCode(self, code: Country.Code,
               locales: List(Locale) = ()) -> Country:
     '''
Exemple #17
0
 def getAll(self,
            locales: List(Locale) = (),
            offset: int = None,
            limit: int = LIMIT_DEFAULT,
            detailed: bool = True) -> Iter(LanguageEntity):
     '''
Exemple #18
0
 def getById(
     self, id: LanguageEntity.Id,
     locales: List(Locale) = ()) -> LanguageEntity:
     '''
Exemple #19
0
 def getAllAvailable(self,
                     locales: List(Locale) = (),
                     offset: int = None,
                     limit: int = LIMIT_DEFAULT,
                     q: QCountry = None) -> Iter(Country):
     '''
 def getCriterias(self,
                  locales: List(Locale),
                  q: QQueryCriteria = None) -> Iter(QueryCriteria):
     '''
Exemple #21
0
 def getByCode(self, code: Language.Code,
               locales: List(Locale) = ()) -> Language:
     '''
Exemple #22
0
 def getAllAvailable(self,
                     locales: List(Locale) = (),
                     offset: int = None,
                     limit: int = LIMIT_DEFAULT,
                     q: QLanguage = None) -> Iter(Language):
     '''
Exemple #23
0
class AsIn:
    '''
    Provides query for properties that can be managed by 'IN' function applied to a list.
    '''

    values = List(str)
Exemple #24
0
from ally.http.spec.server import IDecoderHeader, IEncoderHeader
from ally.internationalization import _
from babel import numbers as bn, dates as bd
from babel.core import Locale
from datetime import datetime
import logging

# --------------------------------------------------------------------

log = logging.getLogger(__name__)

# --------------------------------------------------------------------

FORMATTED_TYPE = (Number, Percentage, Date, Time, DateTime)
# The formatted types for the babel converter.
LIST_LOCALE = List(TypeLocale)
# The locale list used to set as an additional argument.

class FormatError(Exception):
    '''
    Thrown for invalid formatting.
    '''
    def __init__(self, message):
        assert isinstance(message, str), 'Invalid message %s' % message
        self.message = message
        super().__init__(message)

# --------------------------------------------------------------------

class RequestDecode(Context):
    '''