Invention Tautology

def private$instance$key():
    return:

def hash$(s):
    if is$string(s):
        return 'components/services/entropy/sha256'(s)

    if is$sequence(s):
        kwd = keywords$()
        r = []

        for x in s:
            r.append(kwd[x])

        return hash$(''.join(r))


ia = call.assets.Itham
db = ia.components.database.code.db$attach$memory(db.value) <- db:
    signature$db:
        signatures(table):
            - owner: string
            - contentId: string
            - signature: string

        masks(table):
            - owner: string
            - mask_name: string


# signing = ia.server.kernel.class.defClass \
#     ('signing', [], signing, db = db) <- signing:

def database$():
    return db


def sign$content(owner, contentId, content):
    sContentId = string(contentId)

    chk = hash$(['key', 'owner', 'contentId', 'content'], \
            key = private$instance$key(), \
            owner = owner, contentId = sContentId, \
            content = content)

    .db.signatures(owner, sContentId, chk).save()

    return mapping(contentId = sContentId, \
                   signature = chk)

def verify$signature(owner, contentId, chk):
    r = false
    for s in .db.signatures.query(mapping(owner = owner, contentId = contentId)):
        # if s.signature == chk:
        #     return true

        r = s.signature == chk
        break

    return r


def signature$(s):
    return namespace \
        (contentId = s.contentId, \
         signature = s.signature)

def known$signatures(owner):
    return sequence(map(signature$, .db.signatures \
        .query(mapping(owner = owner))))

def known$signatures$all():
    r = mapping()
    for s in .db.signatures.all():
        r.setdefault(s.owner, []) \
            .append(signature$(s))

    return r


def mask$(owner, mask$name):
    if is$not$none(unmask$(mask$name)):
        raise(value$error, 'Mask name already used')

    .db.masks(owner, mask$name).save()

def unmask$(mask$name):
    r = none
    for m in .db.masks.query(mapping(mask_name = mask$name)):
        r = m.owner
        break

    return r


def generate$contentId(owner):
    scatter$args('owner', ['n', '10'], ['tries', 1000])
    ns = mapping(n = integer(n))

    gen = action(run$python, code, ns) <- code:
        from string import ascii_letters
        from random import choice

        __return = ''.join(choice(ascii_letters) for x in range(n))

    contentId = none

    for x in range(tries):
        contentId = gen()
        s = none

        for s in .db.signatures.query(mapping(owner = owner, contentId = contentId)):
            break

        if is$none(s):
            break

    if is$not$none(contentId):
        return contentId

    raise(value$error, 'Max tries reached (%s)' % tries)


sign(view):
    context(trigger)::
        if request.method == 'POST':
            post = request.POST
            owner = request.user.securityContext(programmer)
            contentId = generate$contentId(owner)

            r = sign$content(owner, contentId, post['content'])
            return 'text/json/dumps'(r)

    template::
        <form method="POST">
            <input type="">
            <input type="file" name="content-file">
            <br /><input type="submit">
            </form>

mask(view):
    context(trigger)::
        if request.method == 'POST':
            owner = request.user.securityContext(programmer)
            mask$(owner, request.POST['mask$name'])

verify(view):
    context(trigger)::
        if is$deep$view(path):
            scatter(path, 'mask', 'contentId', 'signature')
        else:
            if request.method == 'POST':
                post = request.POST
            else:
                post = request.GET

            try: mask = ['mask']
            except key$error:
                owner = post['owner']
            else:
                # assert not 'owner' in request.POST
                owner = unmask$(mask)

            contentId = post['contentId']
            chk = post['signature']

        r = verify$signature(owner, contentId, chk)
        return 'text/json/dumps'(r == true)

    usage:
        function public$sign(mask$name, content)
        {
            $.post('mask', {mask$name}).then

            (() => $.post('sign', {content},
              function (chk)
              { $.get(`verify/${mask$name}/${chk.contentId}/{chk.signature}`,
                (isVerified) => console.log(`Verified: ${isVerified}`)); }));
        }


# {'contentId': 'qYbrkqWHOo', 'signature': 'f9a2b612f3ddddbfb1672ee57ca3364ce56e61c6db2921dec6e7d6a7ca75149b'}
# cmr: jul17th2023-1 fa2312470c69f63eefac7bd86cf6642cb01f70e7a783ce17bc312cbc2ed7310c