<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
   xmlns:red="http://redfoot.net/2002/10/red#">

  <red:Python rdf:ID="view">
    <rdfs:label>Redsite Outer page</rdfs:label>
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]


uri = term(request.get_parameter("uri"))
if uri:
    print "000", uri
    rednode.add((uri, RED["all"], Literal("1")))

cached = {}

for context in rednode.contexts():
    cached_on = first(rednode.objects(context, RED["cached_on"]))
    if cached_on:
        seconds = parse_date_time(cached_on)
        timestamp = strftime("%I:%M:%S%p, %B %d, %Y - UTC", gmtime(seconds))
    else:
        timestamp = " - "
    cached[(timestamp, context)] = 1

cached = cached.keys()        
cached.sort(lambda a, b: 0-cmp(a, b))

response.write("<div>Num: %s</div>" % len(cached))

response.write("""\
<form action="" method="post" name="context_form">
  <input name="uri" type="hidden" value=""/>
  <input name="command" type="hidden" value=""/>
""")

for timestamp, url in cached:
    response.write("""\
  <div>
""")

    source = rednode[url][SOURCE]
    if not source:
        source = rednode[url][RDFS_LABEL]
    response.write("""<a href="context?id=%s">%s</a>""" % (quote(url.n3()), source))
    response.write("""\
  </div>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>

  <red:Python rdf:ID="add">
    <red:codestr>
<![CDATA[

from time import mktime, time, gmtime, strftime, timezone, altzone, daylight

from xml.sax.saxutils import quoteattr, escape

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]

uri = request.get_parameter("add_uri")
if uri:
    uri = URIRef(uri)
else:
    uri = term(request.get_parameter("uri"))
if uri:
    try:
        rednode.async_load(uri)
    except Exception, e:
        response.write("""<div style="color: red">%s</div>""" % e)

response.write("""\
<form action="" method="post" name="context_form">
  <input name="uri" type="hidden" value=""/>
  <input name="command" type="hidden" value=""/>
""")

response.write("""\
  <input value="add" type="submit"/>
  <input name="add_uri" type="text" size="60"/>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>

  <red:Python rdf:ID="seeAlso">
    <red:codestr>
<![CDATA[

rednode.schedule_seeAlso()

from time import mktime, time, gmtime, strftime, timezone, altzone, daylight

from xml.sax.saxutils import quoteattr, escape

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]
TIMESTAMP = INFORMATION_STORE["timestamp"]

uri = request.get_parameter("add_uri")
if uri:
    uri = URIRef(uri)
else:
    uri = term(request.get_parameter("uri"))
if uri:
    try:
        rednode.load(uri)
    except Exception, e:
        response.write("""<div style="color: red">%s</div>""" % e)

cached = {}
#
for url in rednode.objects(None, RDFS["seeAlso"]):
    if not isinstance(url, URIRef):
        continue
    context = first(rednode.subjects(SOURCE, url))
    if not context:
        cached[url] = 1

cached = cached.keys()        
cached.sort(lambda a, b: 0-cmp(a, b))

response.write("""\
<form action="" method="post" name="context_form">
  <input name="uri" type="hidden" value=""/>
  <input name="command" type="hidden" value=""/>
""")

response.write("""\
  <input value="add" type="submit"/>
  <input name="add_uri" type="text" size="60"/>
""")

for url in cached:
    response.write("""\
  <div>
""")

    response.write("""
<input value="add" type="button"
       onclick="context_form.uri.value='%s'; context_form.command.value='load'; context_form.submit()"/>""" % escape(url.n3()))

    response.write("""
<a href="%s">%s</a>""" % (url, rednode.label(url)))

    exception = first(rednode.objects(url, RED["exception"]))
    if exception:
        response.write(""", %s""" % exception)
    response.write("""\
  </div>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>

  <red:Python rdf:ID="context">
    <red:codestr>
<![CDATA[

from urllib import quote
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight

from xml.sax.saxutils import quoteattr, escape

from rdflib.util import first
from rdflib.Resource import Resource

RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]
TIMESTAMP = INFORMATION_STORE["timestamp"]
UPDATE_PERIOD = INFORMATION_STORE["updatePeriod"]

response.write("""<h2>Context</h2>""")

id = term(request.get_parameter("id", None))
if id:
    remove = request.get_parameter("remove", None)
    if remove:
        rednode.remove_context(id)

    reload = request.get_parameter("reload", None)
    if reload:
        rednode.reload_context(id)        
        try:
            pass
            #rednode.reload_context(id)
        except Exception, e:
            response.write("""<div style="color: red">%s</div>""" % e)
        
    if id in rednode.contexts():
        response.write("""
<a href="/?facet=http://redfoot.net/2003/01/01/context%%23output&id=%s">View</a>
""" % quote(id.n3()))
        
        
        context = Resource(id, rednode)
        update_period = request.get_parameter("update_period", None)
        if update_period:
            store = rednode.get_context(id)
            store[id][UPDATE_PERIOD] = Literal(update_period)
            rednode.schedule_context(id)

        response.write("""
      <dl>
        <dt>Identifier</dt>
        <dd>%s</dd>
        <dt>Source</dt>
        <dd><a href="%s">%s</a></dd>
        <dt>Timestamp</dt>
        <dd>%s</dd>
      </dl>

        """ % (id, context[SOURCE], context[SOURCE], context[TIMESTAMP]))

        RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
        for s in rednode.subjects(RDFS["seeAlso"], context[SOURCE]):
            response.write("""<a href="%s">%s</a>""" % (s, s))
            
        response.write("""
      <form action="" method="post" name="update_form">
        <input name="update_period" value="%s">
        <input name="update" type="hidden" value="1"/>
        <input type="submit" value="update"/>
      </form>
      """ % context[UPDATE_PERIOD] or '')
        response.write("""
      <form action="" method="post" name="reload_form">
        <input name="reload" type="hidden" value="%s"/>
        <input type="submit" value="reload"/>
      </form>
      """)
        response.write("""        
      <form action="" method="post" name="remove_form">
        <input name="remove" type="hidden" value="1"/>
        <input type="submit" value="remove"/>
      </form>
      """)
    else:
        response.write("""
          <p>No such context.</p>
        """)

    view = request.get_parameter("view", None)
    if view:
        response.write("<pre>")
        store = ContextStore(rednode, id)
        store.output(response)
        response.write("</pre>")        

]]>
    </red:codestr>
  </red:Python>


      <red:Facet rdf:ID="output">
        <rdfs:label>RSS Item</rdfs:label>
        <red:code>
          <red:Python>
            <red:codestr>
<![CDATA[

response.set_header("Content-Type", "text/xml")
id = term(request.get_parameter("id"))
context = rednode.get_context(id)
context.output(response)

]]>
            </red:codestr>
          </red:Python>
        </red:code>

      </red:Facet>  	



  <red:Python rdf:ID="errors">
    <rdfs:label>Redsite Outer page</rdfs:label>
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]


cached = {}

g = rednode.triples((None, INFORMATION_STORE["updateEvent"], None))
for context, p, update_event in g:
    if update_event:
        error = first(rednode.objects(update_event, INFORMATION_STORE["error"]))
        if error:
            timestamp = first(rednode.objects(update_event, DATE)) or Literal('')
            cached[(timestamp, error, context)] = 1

cached = cached.keys()        
cached.sort(lambda a, b: 0-cmp(a, b))

for timestamp, error, context in cached:
    response.write("""\
  <div>
""")

    source = rednode[context][SOURCE]
    if not source:
        source = rednode[context][RDFS_LABEL]
    #else:
    #    rednode.schedule_context(context)        
    response.write("""<a href="context?id=%s">%s</a>: %s""" % (quote(context.n3()),
                                                               source, error))
    response.write("""\
  </div>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>

  <red:Python rdf:ID="http_status">
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]


cached = {}

for context in rednode.contexts():
    update_event = first(rednode.objects(context, INFORMATION_STORE["updateEvent"]))
    if update_event:
        http_status = first(rednode.objects(update_event, INFORMATION_STORE["http_status"]))
        if http_status and http_status!="304":
            timestamp = first(rednode.objects(update_event, DATE)) or ''
            cached[(timestamp, http_status, context)] = 1

cached = cached.keys()        
cached.sort(lambda a, b: 0-cmp(a, b))

for timestamp, http_status, context in cached:
    response.write("""\
  <div>
""")

    source = rednode[context][SOURCE]
    if not source:
        source = rednode[context][RDFS_LABEL]
    response.write("""<a href="context?id=%s">%s</a>: %s""" % (quote(context.n3()),
                                                               source, http_status))
    response.write("""\
  </div>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>


  <red:Python rdf:ID="errors2">
    <rdfs:label>Redsite Outer page</rdfs:label>
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]


cached = {}

for context in rednode.contexts():
    update_event = first(rednode.objects(context, INFORMATION_STORE["updateEvent"]))
    if update_event:
        error = first(rednode.objects(update_event, INFORMATION_STORE["error"]))
        if error:
            timestamp = first(rednode.objects(update_event, DATE)) or ''
            cached[(timestamp, error, context)] = 1

cached = cached.keys()        
cached.sort(lambda a, b: 0-cmp(a, b))

for timestamp, error, context in cached:
    response.write("""\
  <div>
""")

    source = rednode[context][SOURCE]
    if not source:
        source = rednode[context][RDFS_LABEL]
    response.write("""<a href="%s">%s</a>: %s""" % (source, source, error))
    response.write("""\
  </div>
""")

response.write("""\
</form>
""")

]]>
    </red:codestr>
  </red:Python>



  <red:Python rdf:ID="clear">
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]


cached = {}

g = rednode.subjects(TYPE, INFORMATION_STORE["UpdateEvent"])
for update_event in g:
    if update_event:
        rednode.remove_triples((update_event, None, None))

]]>
    </red:codestr>
  </red:Python>


  <red:Python rdf:ID="content-type">
    <red:codestr>
<![CDATA[
    
from time import mktime, time, gmtime, strftime, timezone, altzone, daylight
from xml.sax.saxutils import quoteattr, escape
from urllib import quote

from rdflib.util import first
from rdflib.util import date_time, parse_date_time

RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
RED = Namespace("http://redfoot.net/2002/11/05/red#")
HTTP_HEADER = Namespace("http://rdflib.net/2002/http_header#")
INFORMATION_STORE = Namespace("http://rdflib.net/2002/InformationStore#")
CONTEXT = INFORMATION_STORE["Context"]
SOURCE = INFORMATION_STORE["source"]

for type in rednode.objects(None, HTTP_HEADER["content-type"]):
    response.write("""<li>%s</li>""" % type)

]]>
    </red:codestr>
  </red:Python>

  <rdf:Description rdf:about="http://eikeon.com/2003/01/01/contexts/type">
    <rdfs:label>Contexts</rdfs:label>
    <red:facet>
      <red:Facet>
        <red:outer rdf:resource="http://eikeon.com/2003/01/01/contexts/#outer"/>
        <red:code rdf:resource="http://redfoot.net/2003/01/01/context#content-type"/>
      </red:Facet>      
    </red:facet>    
  </rdf:Description>

</rdf:RDF>  
