Hi rocket scientists. At UDS, Laura Czajkowski ask me about how Launchpad could solve the problem where membership in a team is contingent on a signed code of conduct. This issue is not a priority for Lp stakeholders, and the implementation of the feature is complex. I think this feature would be valuable to several Lp communities and it might be developed in collaboration.
I have a good knowledge of how teams membership works and how the Ubuntu
Code of Conduct works (and often does not). I want help defining an
clear implementation path that Lp contributors can confidently complete
in few weeks.
Introducing team agreements
===========================
There is a general and a specific bug where team membership is
predicated on an agreement. The agreement might be a code of conduct or
a contributors agreement. User will digitally sign the agreement and Lp
will track the version signed.
Support for custom code of conduct like forms
https://bugs.launchpad.net/launchpad/+bug/48551
Leadership CoC not given to Ubuntu Leaders
https://bugs.launchpad.net/launchpad/+bug/392976
As a team owner,
I want membership in my team to be predicated on a signed agreement,
so that it is clear what the terms of membership are.
As a team member,
I want to read and sign a team agreement
so that I can contribute to a team.
As a team owner,
I want to upload a new version of an agreement,
so that all current members need to sign it.
As a team member,
I want to see which users have not assigned a new agreement
so that I can contact the user or remove the user from the team.
Open questions
--------------
Can a team have more than one concurrent agreement?
Do new versions always require new signing?
How do team admins know that users need to sign an agreement.
Do users need to assign the agreement /before/ being approved, during
approval, or after approval?
Can I add a team to a team that has an agreement? Who signs?
Example agreements
------------------
* Code of Conduct
* Contributor/ownership agreement
Required information to operate
-------------------------------
class CodeOfConduct:
implements(ICodeOfConduct)
name = Attribute("The short name of the agreement used for URLs.")
dispaly_name = Attribute("The name of the agreement used in text.")
version = Attribute("The version of the agreement.")
is_current = Attribute("is this the current version of the
agreement.")
datereleased = Attribute("The date the version was released.")
content = Attribute("The content of the signed agreement.")
active = Attribute("Is this agreement signable.")
The SignedCodeOfConduct will need to know the team and the agreement
that was signed
About Ubuntu's Code of Conduct
------------------------------
The principle block to permitting teams to have agreements is the
lack of Lp infrastructure to support them. The Ubuntu code of conduct is
not extensible, it does not even support revisions to the CoC properly. The
problem is hinted at in one bug.
CoC implementation needs to be revisited
https://bugs.launchpad.net/launchpad/+bug/54945
The specific issue is that the Ubuntu CoC is a file on the launchpad
code tree. There can be only one. It is not associated with a team. The
actual Ubuntu agreement is a file in the Launchpad tree. The model class
constructs an instance/version by loading a configuration that is hard
coded in python and the agreement file on disk.
This mechanism is not extensible for team agreements. Teams cannot add
files to the launchpad tree and there is no mechanism to indicate the
version or the team that it applied too.
Refactoring the Ubuntu CoC so that is can be extended
-----------------------------------------------------
Since the Ubuntu CoC is not extensible, we may want to create team
agreements as a separate feature, but solving the existing problem will
ensure the design is general enough to be reused.
* We want a mechanism where agreements can be uploaded to launchpad
by users.
* User can upload a version that supersedes a previous agreement.
* The agreement may need to invalidate previous signed agreements.
* The agreement may be a minor revision/correction that is
existing signed agreements are valid.
Does the Ubuntu CoC need a team to work? Are the signers a member of a
team? Are there advantages to formally making the Ubuntu CoC signers a
team, such as knowing who has signed?
Proposed steps to support team agreements
-----------------------------------------
* Add db/librarian support to store team agreements.
* Migrate the Ubuntu agreement into the db/librarian.
* Create a new model to access the agreement.
* Update the existing signed agreements to know the team and
agreement that was signed.
* Add UI to upload an agreement.
* Update the UI to retrieve an agreement to support teams
* Update the UI to upload a signed agreement to support teams
* Update the membership invite email
* Add UI to edit an agreement's metadata.
* Update the add member code to always send invitation emails
instead of adding the user immediately.
* Update the team invitation to explain there is an agreement and a
link to download it, and instructions about how to sign.
* Update the accept invitation form to also upload the signed
agreement.
* Update the team members view to show that the user has signed the
current agreement.
* Update the edit membership view to show the state of the signed
agreement.
* Add support send an email to members when the current agreement is
updated.
* Maybe update the upload signed agreement form to do better error
checking and fixing since many user corrupt the data pasting it
into to form.
--
Curtis Hovey
http://launchpad.net/~sinzui
signature.asc
Description: OpenPGP digital signature
_______________________________________________ Mailing list: https://launchpad.net/~launchpad-dev Post to : launchpad-dev@lists.launchpad.net Unsubscribe : https://launchpad.net/~launchpad-dev More help : https://help.launchpad.net/ListHelp
