23:16 < waawaamilk> Mjollnir`: we should talk
23:17 < Mjollnir`> yes
23:17 < Mjollnir`> now is good for me
23:17 < waawaamilk> cool
23:17 < Mjollnir`> how is now for y ou >
23:17 < waawaamilk> yep
23:18 < Mjollnir`> ok so
23:18 < waawaamilk> agenda?
23:18 < Mjollnir`> agenda ?
23:18 < Mjollnir`> heh
23:18 < Mjollnir`> well
23:18 < waawaamilk> well we know we're going to do the analysis&design, but I would like to nail down exactly who should do what else
23:19 < Mjollnir`> i want to talk about architecture generally (plugins etc) and data mapping
23:19 < Mjollnir`> oh
23:19 < Mjollnir`> mismatch
23:19 < waawaamilk> they're both good for agenda :)
23:19 < Mjollnir`> ok well
23:19 < Mjollnir`> i don't think we can nail down who is going to do what else since there are two other partners
23:19 < Mjollnir`> and richard if we can make him help
23:19 < Mjollnir`> w
23:20 < waawaamilk> shall we delegate the job of co-ordinating the response to simon to rwyles?
23:20 < Mjollnir`> no
23:20 < Mjollnir`> it should go to ulcc or uni g
23:20 < waawaamilk> how should we contact them?
23:21 < Mjollnir`> i sit across the hall from james
23:21 < waawaamilk> er, how can we all contact each other easily is I guess my real question
23:21 < Mjollnir`> eail
23:21 < Mjollnir`> email
23:21 < Mjollnir`> i think is the best option
23:21 < waawaamilk> james at ulcc, niall at glasgow, dev@mahara for us?
23:22 < Mjollnir`> yep
23:22 < Mjollnir`> and there was someone else at unig
23:22 < Mjollnir`> um
23:22 < Mjollnir`> lorna
23:22 < Mjollnir`> or something
23:22 < waawaamilk> ok
23:22 < waawaamilk> so perhaps we should send an email to them, asking about co-ordinating things
23:22 < Mjollnir`> i am going to talk to james about that t
23:22 < waawaamilk> ok
23:23 < Mjollnir`> did you not see my email about this ?
23:23 < waawaamilk> just looking
23:23 < waawaamilk> you said you'd talk to james about it
23:23 < Mjollnir`> yep
23:23 < waawaamilk> alright
23:24 < Mjollnir`> so i was supposed to talk to him on monday but didn't find time so will talk to him today
23:24 < Mjollnir`> he coordinated the bid
23:24 < Mjollnir`> so i assume he's organisey
23:24 < waawaamilk> ok
23:24 < waawaamilk> well that's all good
23:24 < waawaamilk> so on to real stuff(tm)
23:25 < Mjollnir`> yeah
23:25 < Mjollnir`> so architecture
23:26 < Mjollnir`> what are your feelings about making this a new plugin type
23:26 < waawaamilk> which bit?
23:26 < waawaamilk> there could be several new ones
23:26 < Mjollnir`> i already had people in bcn asking me about ims and making plugins
23:26 < waawaamilk> I think pluggable export types and pluggable import types is good
23:26 < Mjollnir`> what differernt
23:26 < Mjollnir`> yeah
23:27 < Mjollnir`> surely theyr'e the same
23:27 < Mjollnir`> no maybe n ot
23:27 < Mjollnir`> do we have export/ and import/
23:27 < waawaamilk> I think that depends on the kinds of things we might put under there
23:27 < waawaamilk> like... how varied is the scope for export?
23:27 < waawaamilk> do we always export significant amounts, or whole amounts of portfolios?
23:28 < waawaamilk> or can you 'export' just a single file as a 'download' plugin or something?
23:28 < Mjollnir`> well id on't think we can assume that if we export something we necessarily import that format and visa versa
23:28 < waawaamilk> neither
23:28 < waawaamilk> the codepaths are all different anyway
23:28 < waawaamilk> it will probably pay for them to be separate
23:28 < Mjollnir`> yeah
23:28 < waawaamilk> export -> wizard, import -> completely different wizard
23:28 < Mjollnir`> about scope ...
23:28 < Mjollnir`> oh
23:28 < Mjollnir`> hmmmm
23:29 < Mjollnir`> not one wizard, different export formats
23:29 < Mjollnir`> that's what moodle does ?
23:29 < waawaamilk> er
23:29 < waawaamilk> que?
23:29 < Mjollnir`> oh
23:29 < Mjollnir`> i misread
23:29 < Mjollnir`> sorry, i am undercaffeinated
23:29 < waawaamilk> tsk
23:30 < waawaamilk> anyway I think we're both agreeing that it sounds like two plugin types
23:30 < Mjollnir`> yep
23:30 < Mjollnir`> my hands are cold
23:30 < waawaamilk> I think this means we should think about developing two export formats and two import ones then...
23:30 < waawaamilk> at least think about it
23:30 < Mjollnir`> yep
23:30 < Mjollnir`> agree
23:31 < waawaamilk> to test out apis more thorougly
23:31 < waawaamilk> +h
23:31 < waawaamilk> though that might result in quite a bit more work
23:31 < waawaamilk> depending on what two you pick
23:31 < waawaamilk> er, and where are the boundaries?
23:31 < waawaamilk> like..
23:31 < waawaamilk> do we export LEAP? or LEAP2a?
23:32 < Mjollnir`> i think we have one plugint hat is versioned
23:32 < waawaamilk> yeah
23:32 < waawaamilk> it's probably a shitty standard if we'd need two plugins
23:32 < waawaamilk> so there's import plugins (with versions), and export plugins with versions
23:32 < Mjollnir`> yea
23:33 < waawaamilk> ok
23:33 < Mjollnir`> what about transport ?
23:33 < Mjollnir`> can we ignore that for now
23:33 < Mjollnir`> hm
23:33 < waawaamilk> yeah
23:33 < waawaamilk> let's step back
23:33 < waawaamilk> and look at it from a user's point of view
23:33 < Mjollnir`> not really, there's already the beginnings of a framework for it with the moodle stuff
23:34 < waawaamilk> I'm assuming by 'transport' you mean download vs. mnet vs. something else?
23:34 < Mjollnir`> yes
23:35 < waawaamilk> hm
23:35 < waawaamilk> that brings up an issue.. I presume it must be possible to automatedly export and import if possible
23:36 < Mjollnir`> that's the import area
23:36 < Mjollnir`> ok well maybe that means we don't think about transport for nwo
23:36 < waawaamilk> I think we should try walking through what a user will do and see where transports fit in
23:36 < Mjollnir`> because transport is going to get you so far
23:36 < Mjollnir`> ok
23:37 < waawaamilk> so...
23:37 < waawaamilk> a user wants to export their portfolio
23:37 < waawaamilk> they go to a screen for doing this
23:37 < waawaamilk> what do they see?
23:37 < waawaamilk> they need to be able to choose format
23:37 < Mjollnir`> questions
23:37 < waawaamilk> formats might ask questions
23:38 < waawaamilk> (but that's just a note)
23:38 < Mjollnir`> hm,m
23:38 < Mjollnir`> in moodle we ask for target export syste m
23:38 < Mjollnir`> not sure if that changes things
23:38 < waawaamilk> what's an example of such a system?
23:38 < Mjollnir`> i don't think we can make the user know what they want IMS or LEAP
23:38 < Mjollnir`> eg
23:38 < Mjollnir`> mahara
23:39 < Mjollnir`> pebblepad
23:39 < waawaamilk> hm
23:39 < Mjollnir`> elgg :>
23:39 < waawaamilk> it's an interesting point, I can see people potentially wanting both at different times
23:39 < Mjollnir`> yeah
23:39 < Mjollnir`> agree
23:39 < waawaamilk> oh, and a point someone brought up
23:39 < waawaamilk> it should be possible to export a portfolio to what is basically a static website
23:39 < waawaamilk> so that users can actually _see_ it
23:40 < Mjollnir`> from mahara ?
23:40 < waawaamilk> I remember someone saying on the forums that some portfolio vendor in the uk implemented export
23:40 < waawaamilk> and then had to add that feature because of overwhelming demand
23:40 < waawaamilk> yes, from mahara
23:40 < Mjollnir`> yeah
23:40 < Mjollnir`> so we have a HTML export format
23:40 < waawaamilk> actually, I think that would be a great candidate for a second export plugin
23:40 < Mjollnir`> ok
23:40 < Mjollnir`> goodo
23:40 < waawaamilk> not sure we could import it again
23:40 < waawaamilk> but that doesn't matter
23:41 < Mjollnir`> yeah another argument fordifferent plugins
23:41 < waawaamilk> right, so... the user could get to choose between:
23:41 < Mjollnir`> but then we need to have shared code between formats maybe ?
23:41 < Mjollnir`> ret
23:41 < Mjollnir`> er
23:41 < Mjollnir`> sorry, like import/leap and export/leap will share code
23:41 < waawaamilk> either export as format X, or export _for_ system y
23:42 < Mjollnir`> yes
23:42 < Mjollnir`> agree
23:42 < waawaamilk> yeah, shared code
23:42 < waawaamilk> there is potential there
23:42 < Mjollnir`> and if system y has multiple formats it supporrts ?
23:42 < waawaamilk> under lib/leap ?
23:42 < waawaamilk> then mahara picks the most 'compatible' one
23:42 < waawaamilk> given that's a newbie way to pick a format
23:43 < waawaamilk> so we know pebble pad imports format X better than Y, we choose X
23:43 < Mjollnir`> hmm
23:43 < Mjollnir`> how do we maintain a list of systems / foramts ?
23:43 < Mjollnir`> are systems formats too ?
23:43 < waawaamilk> well that's one way to get around the 'system supports multiple formats' thing
23:43 < waawaamilk> we could store a dictionary of system => format
23:44 < waawaamilk> just for this option
23:44 < Mjollnir`> but
23:44 < Mjollnir`> formats are plugins ... if you add a new one
23:44 < Mjollnir`> ... how do you say what systems support it
23:45 < waawaamilk> you don't have to
23:45 < waawaamilk> what I was suggesting was a 1 to 1 mapping of system to most applicable format
23:45 < Mjollnir`> ok so you're a new vendor who wants to add support into mahara to export
23:45 < waawaamilk> used only for the purpose of assisting users with export choice
23:45 < Mjollnir`> so you write a format plugin
23:45 < waawaamilk> and poke the dictionary to add yoursystem => yourformat
23:45 < Mjollnir`> where do you say ' i'm now able to export to pebblepad'
23:45 < Mjollnir`> so you have to customise cord
23:45 < Mjollnir`> core
23:45 < waawaamilk> well
23:45 < waawaamilk> it could be stored the same way applications in mnet are
23:46 < waawaamilk> in a db table
23:46 < waawaamilk> check out mdl_mnet_application I think it is
23:46 < waawaamilk> there's a row for moodle and a row for mahara
23:46 < Mjollnir`> maybe formats can say what ... systems they support
23:46 < Mjollnir`> yes, i am familiar with the table
23:46 < waawaamilk> hm, I think that sounds logically backward
23:47 < Mjollnir`> well yes but hoow else do you make it truly modular
23:47 < Mjollnir`> having to put stuff int he database  is..
23:47 < Mjollnir`> well
23:47 < Mjollnir`> i still don't think it's ideal
23:47 < Mjollnir`> i think mnet applications should be truly pluggable too
23:47 < Mjollnir`> in m oodle as well
23:47 < waawaamilk> add a tiny 'system' plugin?
23:47 < waawaamilk> dunno
23:47 < waawaamilk> shall we flag this as something to think about later?
23:48 < Mjollnir`> yes
23:48 < Mjollnir`> go back to user
23:48 < waawaamilk> ok
23:48 < waawaamilk> so they've chosen what format
23:48 < waawaamilk> do they also get to choose what they export, and how granular is that?
23:48 < Mjollnir`> ideally
23:49 < Mjollnir`> maytbe not now
23:49 < Mjollnir`> -t
23:49 < Mjollnir`> i'm not sure that's a big deal
23:50 < waawaamilk> I think we had notes on this from before
23:50 < Mjollnir`> we're going to ask all artefacts to write out their stuff somehow
23:50 < waawaamilk> I'm trying to find them
23:50 < waawaamilk> just to see what we thought about last time
23:50 < Mjollnir`> whether you do all or some is not necessarily that diufferent
23:50 < waawaamilk> I seem to recall issues with, if the user selected a bunch of views for example, making sure the artefacts all made it
23:50 < Mjollnir`> tyeah
23:50 < Mjollnir`> we did talk sbout that
23:51 < waawaamilk> ah found it
23:51 < waawaamilk> https://wrms.catalyst.net.nz/wr.php?request_id=14098
23:51  * waawaamilk reads attachment
23:52 < Mjollnir`> hey i wrote that
23:52 < waawaamilk> yes you did
23:53 < waawaamilk> ignoring the import stuff in there
23:53 < waawaamilk> there's an interesting point - do we/can we export settings and friend information?
23:53 < Mjollnir`> not now
23:54 < waawaamilk> if I export my portfolio from myportfolio (hah), have my account deleted, then re upload it, should I keep my friends?
23:54 < waawaamilk> ever?
23:54 < Mjollnir`> yes
23:54 < Mjollnir`> hmm
23:54 < Mjollnir`> what's to stop people hacking the fofrmat
23:54 < waawaamilk> that's something to have a look at with regard to the LEAP format maybe
23:54 < Mjollnir`> to make themselves friends with other people
23:54 < waawaamilk> well an import is like other untrusted user data
23:55 < waawaamilk> maybe people can't do it themselves
23:55 < waawaamilk> if an admin does it for them then it can happen
23:55 < Mjollnir`> no I disagree
23:55 < waawaamilk> (if admin chooses)
23:55 < Mjollnir`> hmm
23:55 < Mjollnir`> i am not sure we want to think about friend stuff at the moment
23:55 < Mjollnir`> just portfolio-ish data
23:55 < Mjollnir`> that's what is really important
23:56 < waawaamilk> yep
23:56 < waawaamilk> that goes for settings too yes?
23:56 < Mjollnir`> yes
23:56 < Mjollnir`> views/artefacts
23:56 < Mjollnir`> is what is important
23:56 < Mjollnir`> acess is something else
23:56 < Mjollnir`> that i talked about a little with simon yesterday
23:57 < Mjollnir`> er
23:57 < Mjollnir`> day before
23:57 < Mjollnir`> and we talked about ...
23:57 < Mjollnir`> there's some big EU project to define policies for this sort of thing
23:57 < Mjollnir`> and so what you can do is say , here's the URI for the policy taht relates to this content
23:57 < Mjollnir`> but i think we can worry about that later in this project
23:57 < waawaamilk> sounds complicated
23:57 < Mjollnir`> at the very least they can regrant access somewhere else
23:57 < Mjollnir`> just as long as the CONTENT goes over
23:58 < waawaamilk> so err, that's worth talking about for a little bit anyway
23:58 < waawaamilk> what are we going to to about view access for now?
23:58 < Mjollnir`> now ?
23:58 < Mjollnir`> i don't think it affects the overall architecture
23:58 < waawaamilk> no, though I'm interested in if you have any thoughts about it
23:58 < waawaamilk> don't export it at all?
23:58 < Mjollnir`> hard
23:58 < Mjollnir`> um
23:59 < Mjollnir`> i would be almost tempted to say don't export it for now
23:59 < Mjollnir`> at least for this project
23:59 < Mjollnir`> and sit on it and wait to see how it evolves
23:59 < waawaamilk> ok
23:59 < Mjollnir`> because it's a problem everyone has to solve
23:59 < Mjollnir`> at some point
23:59 < Mjollnir`> and ie xpect there to be a lot of discussion on it over the 5 months
23:59 < waawaamilk> I'm taking notes btw
23:59 < Mjollnir`> and i would rather be involved then with everyone else, than do our own thing now, or even overthink it now
23:59 < Mjollnir`> yeah i am too
23:59 < Mjollnir`> we should email to the list
00:00 < waawaamilk> yep
00:00 < Mjollnir`> i need to email the list about the moodle wrok too
00:00 < Mjollnir`> work
00:00 < Mjollnir`> ok
00:00 < Mjollnir`> back to user
00:00 < Mjollnir`> i'm not sure we need granularity now
00:00 < waawaamilk> so far all we have is them picking a format
00:00 < Mjollnir`> and i don't think we're shortsighting ourselves now by not adding it
00:00 < waawaamilk> and bam they get an export
00:01 < Mjollnir`> format might want to ask questions
00:01 < waawaamilk> yeah it'll probably be fine...
00:01 < waawaamilk> how slow do we think it will be?
00:01 < waawaamilk> heh, actually that question is too soon
00:01 < Mjollnir`> could be huge
00:01 < waawaamilk> what's the general mechanics of an export?
00:01 < Mjollnir`> not necessarily
00:02 < Mjollnir`> if you're going to advocate asking the user
00:02 < Mjollnir`> we could do the export at cron , put it in their file area (or somewhere else) and send them a notification
00:02 < Mjollnir`> that's still user land :)
00:02 < waawaamilk> assuming it'll be teh huge0r
00:02 < Mjollnir`> yeah
00:02 < waawaamilk> let's say we have $big_site
00:02 < waawaamilk> like, millions of users
00:02 < waawaamilk> heavy traffic
00:02 < Mjollnir`> estimating that is quite hard though, I ended up doing something a bit hacky for moodle
00:02 < waawaamilk> user X wants to export
00:03 < waawaamilk> how can we make sure they get their export without killing the site?
00:03 < Mjollnir`> well
00:03 < Mjollnir`> her'es what id id for moodle
00:03 < Mjollnir`> i had three levels
00:03 < Mjollnir`> small: user can just wait for export
00:03 < Mjollnir`> medium: user is warned, but can opt to wait
00:03 < Mjollnir`> large: user must not wait
00:04 < Mjollnir`> this is determined by
00:04 < waawaamilk> (going afk for a copule of minutes, please continue)
00:04 < Mjollnir`> an admin configurable set of thresholds for 1. filesize and 2. # db records (depending on what is being exported)
00:04 < Mjollnir`> we could do something else like
00:04 < Mjollnir`> cross check that with an (admin configurable) config option about load (number of online users)
00:04 < Mjollnir`> it's hacky because you're really asking the admin to make arbitrary decisions
00:05 < Mjollnir`> but the idea is they play around a bit berore figuring out what is right for the site
00:05 < Mjollnir`> and the environment (eg hardware)
00:05 < Mjollnir`> you couldeven have a dedicated server to do exports
00:05 < Mjollnir`> and imports
00:05 < Mjollnir`> webserver i mean
00:06 < Mjollnir`> in fact it might be cool to offer the ability to make the links on another (sub) domain
00:08  * Mjollnir` runs out of stuff to say without any input
00:09 < waawaamilk> back
00:10 < waawaamilk> there's probably only so far we can take any ideas before actually needing to see real performance numbers
00:10 < waawaamilk> we can try architect it so it's as performant as we can make it, and then see what kind of bottlenecks are caused when it's used in the real world
00:11 < waawaamilk> (I was referring to more speculative ideas like links on another subdomain, the other ideas sound reasonable)
00:11 < waawaamilk> what is 'filesize' in the above?
00:11 < Mjollnir`> back
00:11 < Mjollnir`> ah
00:12 < Mjollnir`> so in moodle it's common to be exporting files
00:12 < Mjollnir`> eg assignments
00:12 < Mjollnir`> i was just saying what i did there as example
00:12 < Mjollnir`> btw, have meeting with james at 2
00:12 < waawaamilk> right
00:12 < waawaamilk> I just had an idea
00:13 < Mjollnir`> go
00:13 < waawaamilk> amanda is an example of a really busy thing
00:13 < waawaamilk> it has the concept of estimation built in
00:13 < waawaamilk> and uses that to make decisions about what's going to be bottlenecked and so how it should handle backupruns
00:14 < waawaamilk> I wonder if there would be a way to do estimates based on factors like how many artefacts/views, server load etc.
00:14 < waawaamilk> it's just a slightly more streamlined version of what you did
00:14 < Mjollnir`> well that's kind of what i was getting at
00:14 < Mjollnir`> just with admin intervention
00:15 < waawaamilk> another idea is to limit how many can be happening at any one time
00:15 < waawaamilk> though perhaps that's based on this estimation thing too
00:15 < Mjollnir`> and queue to cron any additional ?
00:15 < Mjollnir`> hm
00:15 < waawaamilk> like...
00:15 < waawaamilk> four people are exporting
00:15 < Mjollnir`> i think we are overengineering for this point
00:15 < waawaamilk> this is causing high load
00:15 < waawaamilk> heh
00:15 < Mjollnir`> i agree ith you though
00:16 < Mjollnir`> but i think you should have config options for all this
00:16 < waawaamilk> anyway, there's a potential issue there that we should investigate in more detail.. in the scope of this initial work?
00:16 < Mjollnir`> number of views before you force queue, number of concurrent exports beofre you force queue, number of online users etc
00:17 < waawaamilk> anyways,
00:17 < Mjollnir`> yup
00:17 < waawaamilk> back to the mechanics of the export itself
00:17 < Mjollnir`> so
00:17 < Mjollnir`> pick format
00:17 < Mjollnir`> get questions
00:17 < Mjollnir`> maybe queue
00:17 < Mjollnir`> get export
00:17 < Mjollnir`> win
00:17 < Mjollnir`> profile
00:18 < Mjollnir`> er
00:18 < Mjollnir`> profit
00:18 < waawaamilk> heh
00:18 < waawaamilk> the ... is the mechanics of the export? :)
00:18 < waawaamilk> hm, where to begin
00:18 < Mjollnir`> yes
00:18 < Mjollnir`> quite
00:18 < Mjollnir`> so one problem i have
00:18 < Mjollnir`> lets start with a rpoblem
00:19 < Mjollnir`> formats are pluggable
00:19 < Mjollnir`> but,
00:19 < Mjollnir`> so are artefacts
00:19 < Mjollnir`> yet,
00:19 < waawaamilk> uhohes
00:19 < Mjollnir`> each artefact must know that it exports to (eg) LEAP element reflection
00:19 < Mjollnir`> say
00:19 < waawaamilk> formats might not be able to be just dropped into the code
00:20 < Mjollnir`> there must be some knowledge of $format in the artefact
00:20 < waawaamilk> maybe artefacts need a export/ directory
00:20 < waawaamilk> artefact/file/export/leap
00:20 < Mjollnir`> and what if it is missing ?
00:20 < waawaamilk> um
00:20 < waawaamilk> I figure that there should be a base way of exporting generic artefacts
00:21 < Mjollnir`> yes
00:21 < waawaamilk> artefact/export/leap or something
00:21 < Mjollnir`> ones that don't contain extra db tables , just artefact, for exmaple
00:21 < waawaamilk> yeah
00:22 < waawaamilk> they'd export as straight leap entries maybe
00:22 < Mjollnir`> hm
00:22 < waawaamilk> and having the artefact/file/export/leap thing would allow the file plugin to say "in leap I export as a selection"
00:22 < waawaamilk> s/I/the file artefacttype/
00:22 < waawaamilk> or image, or folder or whatever
00:22 < Mjollnir`> plugins should be able to say just export as this element type b ut use the basic export method and just override the 'type'
00:22 < Mjollnir`> rather than re-implement the export
00:23 < waawaamilk> yeah the base can do that
00:23 < waawaamilk> by calling api methods/looking in fields for type info
00:24 < Mjollnir`> maybe there's a method to get the element type as well as a method to actuially write the xml (or return it or a data structure or whatever)
00:24 < waawaamilk> yeah exactly
00:24 < Mjollnir`> sweet
00:24 < Mjollnir`> ok
00:25 < waawaamilk> so somewhere there is a base class for exporting artefacts
00:25 < waawaamilk> (export/lib.php maybe)
00:25 < Mjollnir`> i would say artefact/export/leap
00:25 < waawaamilk> yeah
00:25 < waawaamilk> this is potentially overridden in artefact/type/export/leap for certain artefacttypes
00:26 < Mjollnir`> yeah
00:26 < waawaamilk> hm
00:26 < Mjollnir`> but
00:26 < Mjollnir`> here we have a problem
00:26 < Mjollnir`> you have to make an object for each plugin
00:26 < Mjollnir`> no
00:26 < waawaamilk> somehow the artefact has to be able to supposedly export types _without_ knowing about the format
00:26 < Mjollnir`> each artefact TYPE
00:26 < waawaamilk> under what we proposed above
00:27 < waawaamilk> it's all well and good for us to say there's an artefact leap export base class that implements a generic way of exporting artefacts
00:28 < waawaamilk> but that means that the only thing artefacts can export for use by this base class is really generic stuff
00:28 < waawaamilk> otherwise other formats won't be able to use it
00:28 < Mjollnir`> sorry
00:28 < Mjollnir`> confused
00:28 < waawaamilk> sorry
00:28 < waawaamilk> um
00:28 < Mjollnir`> why would other formats want to use it? it's the *leap* base class
00:28 < waawaamilk> the artefact leap exporting base class can't rely on any specific information from artefacts that we don't already have
00:29 < waawaamilk> grr
00:29 < waawaamilk> like...
00:29 < Mjollnir`> still confused
00:29 < Mjollnir`> that's why it's a BASE class
00:29 < Mjollnir`> :)
00:29 < Mjollnir`> by default, it backs up the contents of the artefact table
00:29 < waawaamilk> you: maybe there's a method to get the element type as well as a method to actuially write the xml (or return it or a data structure or whatever)
00:30 < waawaamilk> what I'm saying is
00:30 < Mjollnir`> eys
00:30 < Mjollnir`> yes
00:30 < waawaamilk> we must already have this method
00:30 < waawaamilk> (whether it's a method or simply a get() call or whatever)
00:30 < waawaamilk> you can't have a method specific to leap export format
00:30 < waawaamilk> ... does that help or am I making no sense at all
00:30 < Mjollnir`> in the artefact plugin ?
00:30 < Mjollnir`> 11:30 < waawaamilk> you can't have a method specific to leap export format
00:31 < Mjollnir`> ?
00:31 < waawaamilk> yeah
00:31 < Mjollnir`> but ...
00:31 < Mjollnir`> doesn't that go in artefact/file/export/leap ?
00:31 < Mjollnir`> we just talked about that
00:31 < waawaamilk> artefact plugin != artefact leap export plugin
00:31 < waawaamilk> maybe that's where I"m confused
00:31 < Mjollnir`> which is why i said
00:32 < Mjollnir`> http://paste.dollyfish.net.nz/ec4527
00:32 < Mjollnir`> hehe and then we talked about the generic case and then doubled back :)
00:33 < waawaamilk> humm
00:33 < waawaamilk> I think I got confused for nothing
00:33 < waawaamilk> what was the problem you were seeing now?
00:34 < Mjollnir`> if the artefact plugin doesn't HAVE a leap export plugin in it
00:34 < Mjollnir`> we use the generic base class one
00:34 < Mjollnir`> but
00:34 < Mjollnir`> that might not actually be reasonable
00:34 < Mjollnir`> or complete
00:35 < waawaamilk> there's nothing we can do about that
00:35 < Mjollnir`> no but we can tellt he user
00:35 < waawaamilk> hm
00:35 < waawaamilk> not sure about that
00:35 < Mjollnir`> which means we must enforce artefact/file/export/leap for all plugins , even if empty
00:35 < Mjollnir`> so we can tell teh difference between
00:35 < Mjollnir`> 1. leapis supported, but generic
00:35 < Mjollnir`> and 2. leap is not supported, we're falling back
00:35 < waawaamilk> oh
00:35 < waawaamilk> actually
00:36 < waawaamilk> hmmm
00:36 < Mjollnir`> oh!
00:36 < Mjollnir`> we could do
00:36 < Mjollnir`> get_supoported_export_Formats at install time ?
00:36 < Mjollnir`> install & upgrade
00:36 < waawaamilk> hang on you're getting too far ahead of me
00:36 < Mjollnir`> and import too, but that's much more complicated
00:36 < Mjollnir`> ok
00:36 < waawaamilk> we can't enforce artefact/type/export/format for all plugins
00:37 < waawaamilk> there's no way that's feasable
00:37 < Mjollnir`> no, that's why i switched to 11:35 < Mjollnir`> get_supoported_export_Formats at install time ?
00:37 < waawaamilk> um
00:37 < waawaamilk> I don't understand the difference between your 1 and 2
00:38 < waawaamilk> in 2, what do you fall back to?
00:38 < Mjollnir`> baseclass
00:38 < waawaamilk> and if that's the base class, then what is 1?
00:38 < Mjollnir`> even though it might be incomplete
00:38 < Mjollnir`> tehy are BOTH the base class
00:38 < Mjollnir`> the difference is that the user should be maybe warned that their export is not necessarily complete
00:38 < waawaamilk> in the case of 2 you mean?
00:38 < Mjollnir`> yes
00:38 < Mjollnir`> exactly
00:38 < waawaamilk> right...
00:39 < waawaamilk> so what you're doing is giving a way for us to say that the baseclass export is sufficient for a certain artefact type
00:39 < Mjollnir`> yes
00:39 < waawaamilk> right
00:39 < waawaamilk> with you now
00:39 < Mjollnir`> sorry
00:39 < waawaamilk> :)
00:39 < waawaamilk> so err
00:39 < waawaamilk> get_supported_export_formats
00:40 < Mjollnir`> will return like array('leap', 'ims')
00:40 < waawaamilk> an artefact type (e.g. file) might say 'leap' and 'html'
00:40 < waawaamilk> heh
00:40 < Mjollnir`> yes
00:40 < waawaamilk> and might not actually have artefact/file/export/html
00:40  * Mjollnir` removes ims from her brain
00:40 < Mjollnir`> yes
00:40 < waawaamilk> righto
00:40 < waawaamilk> ok so where are we at now?
00:40 < Mjollnir`> um
00:40 < Mjollnir`> so
00:41 < Mjollnir`> these classes we are talking about
00:41 < Mjollnir`> are classes to handle exporting a single entry , not the entire export
00:41 < Mjollnir`> we need two I think - whole export (no interaction with plugins or need to override), and single entry (overridable)
00:42 < Mjollnir`> I would really l ike to come up with a few skeleton classes
00:42 < Mjollnir`> not now
00:42 < Mjollnir`> but soon
00:42 < waawaamilk> two whats?
00:42 < Mjollnir`> classes
00:42 < waawaamilk> oh
00:42 < Mjollnir`> the one we've been talking aboutis for exporting a SINGLE artefact
00:42 < waawaamilk> right
00:42 < waawaamilk> meh, it's two methods of the same class ;)
00:42 < Mjollnir`> and you have to make many of them
00:43 < Mjollnir`> we also want
00:43 < Mjollnir`> no
00:43 < Mjollnir`> i'm not sure about that
00:43 < waawaamilk> I don't see why not...
00:43 < Mjollnir`> i would want one that is completley final
00:43 < Mjollnir`> for the whole export
00:43 < Mjollnir`> i guess you could make final methods for the whole exoprt stuff
00:43 < Mjollnir`> but
00:43 < Mjollnir`> ....
00:43 < waawaamilk> we're talking about a method that generates, in the case of leap, XML?
00:44 < Mjollnir`> well a data structure
00:44 < waawaamilk> ?
00:44 < Mjollnir`> i wouldn't tell the plugins to make xml
00:44 < Mjollnir`> i would tell them to make me a data structure that *i* write to xml
00:44 < Mjollnir`> i = the whole export managery bit
00:44 < waawaamilk> I wouldn't have a problem telling the artefact leap export thing to generate xml
00:44 < Mjollnir`> the plugin ?
00:44 < Mjollnir`> like
00:44 < Mjollnir`> artefact/file/export/leap ?
00:45 < waawaamilk> yeah
00:45 < Mjollnir`> i would get it to set memeber variables in an entry class
00:45 < waawaamilk> otherwise, what's actually different between them all?
00:45 < Mjollnir`> which is why i'm saying two classes
00:45 < Mjollnir`> the difference is the nature of the data structure
00:45 < Mjollnir`> ims will want something entirely different
00:46 < waawaamilk> hm
00:46 < waawaamilk> what is the whole export managery bit and why is it writing the xml?
00:47 < Mjollnir`> well you need some "manager" code to interact with all the plugins, handle asking the user options, keep track of everything and write the file somewhere sensible
00:47 < Mjollnir`> that's essentially the $format class, before any plugins get involved
00:47 < waawaamilk> export/leap/ ?
00:47 < Mjollnir`> yes
00:47 < waawaamilk> ok
00:47 < Mjollnir`> each <entry> (imo) is another class, bound to the artefacttype
00:48 < waawaamilk> so what you're saying is it could be implemented that the artefact/type/export/leap stuff returns datastructures while I'm saying it could be xml
00:48 < Mjollnir`> with subclasses
00:48 < waawaamilk> not that I'm saying I'm write and you're wrong
00:48 < waawaamilk> er,
00:48 < waawaamilk> wrong spelling
00:48 < Mjollnir`>  well i would get it to set member variables rather than return datastructures actually
00:48 < Mjollnir`> like
00:49 < Mjollnir`> whatever <entry> has
00:49 < Mjollnir`> and then the $format class writes out the xml for ech thing based on the member variables
00:49 < waawaamilk> rirght
00:49 < Mjollnir`> do you need pseudo code ?
00:49 < waawaamilk> no I follow
00:49 < Mjollnir`> or did i manage to explain myself
00:49 < Mjollnir`> swee
00:49 < Mjollnir`> tt
00:49 < Mjollnir`> -t
00:49 < waawaamilk> skeleton classes would be helpful :)
00:49 < Mjollnir`> anyway
00:50 < waawaamilk> at some point
00:50 < Mjollnir`> yeah
00:50 < Mjollnir`> i'll do that later
00:50 < Mjollnir`> anyway
00:50 < Mjollnir`> are we ready to talk about import
00:50 < waawaamilk> yeah
00:50 < Mjollnir`> we should have started with that actually
00:50 < Mjollnir`> it's harder
00:50 < waawaamilk> nearly 1am
00:50 < Mjollnir`> ord o you want to break and do it tomorrow
00:50 < Mjollnir`> yeah
00:50 < Mjollnir`> import will be harder
00:50 < waawaamilk> yeah let's break