[import "platform:/resource/AraneaMessageproject/src/aranea.dsl"]

[project Origo prefix=O_]
{
	[namespace Blog]
	{
		// blog add message
		[message Add extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Id of the project"
				title: string notEmpty "Title of the Blog entry"
				url: string notEmpty "URL of the blog-entry"
				diff: string notEmpty "Blog diff"
				revision: integer greaterZero "Revision"
				old_revision: integer greaterEqualZero "Revision before change"
				is_private: boolean "Is the page private?"
			}
		}
		
		[message AddReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "ID of the newly added workitem."
			}
		}		
	}

	[namespace Comment]
	{
		// comment add message
		[message Add extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "ID of the project"
				title: string notEmpty "Title of the comment"
				text: string notEmpty "Comment text"
				reference_url: string notEmpty "URL to the comment"
				is_new: boolean "Is this a new comment or an edited comment"
				comment_type: string notEmpty "Is this a forum topic, a forum post, a wiki comment, a picture comment, ..."
				is_private: boolean "Is the page private?"
			}
		}
		
		[message AddReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "ID of the newly added workitem."
			}
		}		
	}
	
	[namespace Commit]
	{
		// commit add message
		[message Add]
		{
			properties=
			{
				user: string notEmpty "Name of the user"
				project: string notEmpty "Name of the project"
				revision: integer greaterZero "Revision of the commit"
				commit_log: string notVoid "Log of the commit"
				diff: string notVoid "Diff of the commit"
			}
		}
		
		[message AddReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "ID of the newly added workitem."
			}
		}
	}
	
	[namespace Community]
	{
		// community create message
		[message Create extends=Aranea::Default::Session]
		{
			properties=
			{
				name: string notEmpty "Community name"
				description: string notEmpty "Description"
			}
		}
		
		// community change description message
		[message ChangeDescription extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				description: string notEmpty "New description"
			}
		}
		
		// community change group message
		[message ChangeGroup extends=Aranea::Default::Session]
		{
			properties=
			{
				community: string notEmpty "Community name"
				user: string notEmpty "User name"
				group: integer greaterEqualZero "Access group id"
			}
		}

		// community delete wiki page message		
		[message DeleteWikiPage extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				wiki_title: string notEmpty "Wiki title"
			}
		}

		// community list members message		
		[message ListMembers extends=Aranea::Default::Session]
		{
			properties=
			{
				community: string notEmpty "Community name"
				group: integer greaterEqualZero "Access group id"
			}
		}
		
		// community edit wiki page message		
		[message EditWikiPage extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				title: string notEmpty "Wiki title"
				text: string notVoid "Wiki text"
				private: boolean "Private wiki page"
			}
		}

		// community add wiki page message		
		[message AddWikiPage extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				title: string notEmpty "Wiki title"
				text: string notVoid "Wiki text"
				private: boolean "Private wiki page"
			}
		}
		
		// community list message		
		[message List extends=Aranea::Default::Session]
		{}
		
		// community list projects message		
		[message ListProjects extends=Aranea::Default::Session]
		{
			properties=
			{
				community: string notEmpty "Community name"
			}
		}

		// community add project message		
		[message AddProject extends=Aranea::Default::Session]
		{
			properties=
			{
				community: string notEmpty "Community name"
				project: string notEmpty "Project name"
			}
		}

		// community retrieve reply message		
		[message RetrieveReply]
		{
			properties=
			{
				community_id: integer greaterZero "Community ID"
				name: string notEmpty "Name"
				description: string notVoid "Description"
				logo: string notEmpty "Logo"
			}
		}
		
		// community retrieve message
		[message Retrieve extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
			}
		}

		// community list wiki pages reply message		
		[message ListWikiPagesReply]
		{
			properties=
			{
				wiki_list: sequence<string> notVoid "Wiki pages list"
			}
		}

		// community list reply message		
		[message ListReply]
		{
			properties=
			{
				community_list: sequence<string> "Community list"
			}
		}

		// community delete message
		[message Delete extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
			}
		}

		// community list wiki pages message
		[message ListWikiPages extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
			}
		}
		
		// community remove project message
		[message RemoveProject extends=Aranea::Default::Session]
		{
			properties=
			{
				community: string notEmpty "Community name"
				project: string notEmpty "Project name"
			}
		}
		
		// community retrieve wiki page message
		[message RetrieveWikiPage extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				wiki_title: string notEmpty "Wiki title"
			}
		}

		// community retrieve wiki page reply message
		[message RetrieveWikiPageReply]
		{
			properties=
			{
				title: string notEmpty "Wiki title"
				text: string notVoid "Wiki text"
				private: boolean "Is wiki page private?"
			}
		}

		// community rename wiki page message
		[message RenameWikiPage extends=Aranea::Default::Session]
		{
			properties=
			{
				community_name: string notEmpty "Community name"
				old_title: string notEmpty "Old wiki title"
				new_title: string notEmpty "New wiki title"
			}
		}
	}
	
	[namespace System]
	{
		// system status message
		[message Status extends=Aranea::Default::Session]
		{}
		
		// system mail all message
		[message MailAll extends=Aranea::Default::Session]
		{
			properties=
			{
				subject: string notEmpty "Subject of the mail"
				text: string notEmpty "Text of the mail"
			}
		}
		
		[message RetrieveAllEmail]
		{
			properties=
			{
			}
		}
		
		[message RetrieveAllEmailReply]
		{
			properties=
			{
				addresses: sequence<string> notVoid "All email addresses in the system."
			}
		}		
	}
	
	[namespace User]
	{
		[message AddBookmark extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project ID"
			}
		}
		 
		[message AuthorizedForCommunity extends=Aranea::Default::Session]
		{
			properties=
			{
				instruction: string notEmpty "Instruction we want to check."
				community_name: string notVoid "Community name for the instruction."
			}
		}

		[message AuthorizedForProject extends=Aranea::Default::Session]
		{
			properties=
			{
				instruction: string notEmpty "Instruction we want to check."
				project: integer greaterEqualZero "Project ID"
			}
		}
		 
		[message ChangeAccountEnabled]
		 {
		 	properties=
		 	{
		 		name: string notEmpty "Name of the user"
		 		enabled: boolean "Shall the account be enabled?"
		 	}
		 }

		[message ChangeEmail extends=Aranea::Default::Session]
		{
			properties=
			{
				email_address: string notEmpty "New email address"
			}
		}

		[message ChangePassword]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
				password: string notEmpty "Password to be changed"
			}
		}
		
		[message ChangeProfileVisible extends=Aranea::Default::Session]
		{
			properties=
			{
				value: integer greaterEqualZero "Profile visibility encoded into an INTEGER"
			}
		}
		
		[message Create]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
				password: string notEmpty "Password of the user"
				email: string notEmpty "Email of the user"
			}
		}

		[message DisableAccount extends=Aranea::Default::Session]
		{
		  properties=
		  {
		    user_name: string notEmpty
		  }
		}

		[message KeyGenerate extends=Aranea::Default::Session]
		{
		}

		[message Key extends=Aranea::Default::Session]
		{
		}

		[message KeyReply]
		{
			properties=
			{
				key: string notEmpty "Key of the user"
			}
		}

		[message ListBookmark extends=Aranea::Default::Session]
		{
			properties=
			{
				username: string notEmpty "username to list bookmarks for"
			}
		}

		[message ListBookmarkReply]
		{
			properties=
			{
				project_list: map<string> notVoid "Project list"
			}
		}

		[message ListCommunities extends=Aranea::Default::Session]
		{
			properties=
			{
				username: string notEmpty "username to list communities for"
			}
		}

		[message ListFriends extends=Aranea::Default::Session]
		{
			properties=
			{
				username: string notEmpty "username to list friends for"
			}
		}

		[message ListFriendsReply]
		{
			properties=
			{
				friend_list: map<
					record(friend, [
						name: string notEmpty;
						icon: string notVoid;
						real_name: string notEmpty
					])
				> notVoid "Friend list"
			}
		}

		[message List]
		{
			properties=
			{
				user_list: map<string> notVoid "User list"
			}
		}

		[message ListReportedIssues extends=Aranea::Default::Session]
		{
			properties=
			{
        // Paging information
        start: integer greaterEqualZero "The start index of the issue list"
        limit: integer greaterZero "The maximum number of issue to be returned"
        sort_column: string notVoid "The sort column, must match a database column"
        sort_order: string notVoid "Sorting orther, either `asc' or `desc'"
			}
		}

		// issue list reply messasge
		[message ListReportedIssuesReply]
		{
			properties=
			{
				issue_list: sequence<record(issue, [
					project_issue_id: integer greaterEqualZero;
					title: string notEmpty;
					deadline: integer greaterEqualZero;
					work_amount: integer greaterEqualZero;
					project_name: string notEmpty;
					last_updated: integer greaterZero;
					tags: string notVoid;
					status: string notVoid;
					assigned: string notVoid
				])> notVoid "Issue list"
			}
		}

		[message ListWorkitemSubscription extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterEqualZero "ID of the project"
			}
		}

		[message LoginAuthenticated]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
			}
		}

		[message LoginKey]
		{
			properties=
			{
				user_key: string notEmpty "Name of the user"
				app_key: string notEmpty "Application key of the user"
			}
		}

		[message Login]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
				password: string notEmpty "Password of the user"
			}
		}

		[message MyEmail extends=Aranea::Default::Session]
		{
		}

		[message MyName extends=Aranea::Default::Session]
		{
		}

		[message MyPassword extends=Aranea::Default::Session]
		{
		}

		[message ProcessFriendshipRequest extends=Aranea::Default::Session]
		{
			properties=
			{
				requester: string notEmpty "Initial friendship requester"
				accept: boolean "Status whether to accept request or reject request"
			}
		}

		[message ProcessFriendshipRequestReply]
		{
			properties=
			{
				requester_mail_address: string notEmpty "Mail address of requester"
				requestee_username: string notEmpty "Username of requestee"
				requestee_name: string notVoid "Name of requestee"
			}
		}

		[message ProfileVisible]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
			}
		}

		[message RemoveBookmark extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project ID"
			}
		}

		[message RemoveFriendship extends=Aranea::Default::Session]
		{
			properties=
			{
				friend: string notEmpty "Friend"
			}
		}

    // user.reported_issues_count message
    [message ReportedIssuesCount extends=Aranea::Default::Session]
    {
      properties=
      {
      }
    }

    // user.reported_issues_count reply message
    [message ReportedIssuesCountReply]
    {
      properties=
      {
        issue_count: integer greaterEqualZero "The number the user's reported issues."
      }
    }

		[message RequestFriendship extends=Aranea::Default::Session]
		{
			properties=
			{
				requestee: string notEmpty "requestee"
			}
		}

		[message RequestFriendshipReply]
		{
			properties=
			{
				requestee_mail_address: string notEmpty "Mail address of requestee"
				requester_username: string notEmpty "Username of requester"
				requester_name: string notVoid "Name of requester"
			}
		}

		[message ResetIcon extends=Aranea::Default::Session]
		{
		}


		[message ResetPassword]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
			}
		}

		[message ResetPasswordReply]
		{
			properties=
			{
				password: string notEmpty "Password of the user"
				email: string notEmpty "Email of the user"
			}
		}


		[message RetrieveEmail]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
			}
		}

		[message RetrieveFtpConfiguration]
		{
			properties=
			{
			}
		}

		[message RetrieveInformation extends=Aranea::Default::Session]
		{
			properties=
			{
				user_name: string notEmpty "User name"
			}
		}

		[message RetrieveInformationReply]
		{
			properties=
			{
			  integer_settings: map<integer> notVoid "Settings of type integer"
			  double_settings: map<double> notVoid "Settings of type double"
			  string_settings: map<string> notVoid "Settings of type string"
			}
		}
		
	    [message RetrieveValidSettingNames]
	    {
	      properties=
	      {
	      }
	    }
	
	    [message RetrieveValidSettingNamesReply]
	    {
	      properties=
	      {
	        names: map<string> notVoid "The list of valid setting names"
	      }
	    }

		[message RetrieveSubversionConfiguration]
		{
			properties=
			{
			}
		}

		[message RetrieveGitConfiguration]
		{
			properties=
			{
			}
		}
		
		[message RetrieveGitConfigurationReply]
		{
			properties=
			{
				projects: map<record(project_access, [
					read: sequence<string>;
					rw: sequence<string>
				])> notVoid "Issue list"
			}
		}
		
		[message RetrievePassword]
		{
			properties=
			{
				name: string notEmpty "Name of the user"
			}
		}

		[message RetrieveUserFromEmail]
		{
			properties=
			{
				email: string notEmpty "Email of the user"
			}
		}

		[message SendMessage extends=Aranea::Default::Session]
		{
			properties=
			{
				username: string notEmpty "Username to send message to"
				subject: string notEmpty "Subject of the message"
				message: string notEmpty "Body of the message"
			}
		}

		[message SendMessageReply]
		{
			properties=
			{
				recipient_email_address: string notEmpty "Mail address of recipient"
				recipient_name: string notEmpty "Name of recipient"
				sender_name: string notEmpty "Name of sender"
				sender_username: string notEmpty "Username of sender"
			}
		}

		// for now: use A_SESSION_MESSAGE instead
		[message Session extends=Aranea::Default::Session]
		{
		}

		[message SetIcon extends=Aranea::Default::Session]
		{
			properties=
			{
				icon: string notEmpty "Filename of new user icon"
			}
		}

		[message SetInformation extends=Aranea::Default::Session]
		{
			properties=
			{
				informations: sequence<record(information, 
					[
						information_type: string;
						information_value: string
					])> notVoid "List of informations with [information_type, information_value]"
			}
		}

		[message SetWorkitemSubscription extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "ID of the project"
				settings: sequence<record(workitem_setting, 
					[
						workitem_type: integer;
						subscription_type: integer;
						is_enabled: boolean
					])> notEmpty "List of settings with [workitem_type, subscription_type, is_enabled]"
			}
		}

		[message WorkitemSubscriptions]
		{
			properties=
			{
				subscriptions: sequence<record(subscription_setting, 
					[
						workitem_type: integer;
						subscription_type: integer
					])> notVoid "List of settings with [workitem_type, subscription_type]"
			}
		}
	}

	[namespace Wiki]
	{
		// wiki add message
		[message Add extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				title: string notEmpty "Wiki title"
        		url: string notEmpty "URL of the blog-entry"
				diff: string notEmpty "Diff"
				revision: integer greaterZero "Revision"
				old_revision: integer greaterEqualZero "Previous revision"
				is_private: boolean "Is the page private?"
			}
		}
		
		[message AddReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "ID of the newly added workitem."
			}
		}
		
		// wiki render html message
		[message RenderHtml extends=Aranea::Default::Session]
		{
			properties=
			{
				wiki_text: string notVoid "Text of the wiki"
				project_id: integer greaterZero "Project id"
			}
		}
	}
	
	[namespace Workitem]
	{
    // workitem.count message
    [message Count extends=Aranea::Default::Session]
    {
      properties=
      {
        project_id_list: sequence<integer> notVoid "List of project IDs for which to retrieve workitems"
        unread_only: boolean "Only unread workitems"
        filter_type: integer greaterEqualZero "Only return work-items of `type' (use 0 for listing all types)"
      }
    }
    
    // workitem.count reply message
    [message CountReply]
    {
      properties=
      {
        workitem_count: integer greaterEqualZero "The number of workitems of the user."
      }
    }
    
		// list message
		[message List extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id_list: sequence<integer> notVoid "List of project IDs for which to retrieve workitems"
        unread_only: boolean "Only unread workitems"
        filter_type: integer greaterEqualZero "Only return work-items of `type' (use 0 for listing all types)"
				// Paging information
				start: integer greaterEqualZero "The start index of the work item list"
        limit: integer greaterZero "The maximum number of work items to be returned"
        sort_column: string notVoid "The sort column, must match a database column"
        sort_order: string notVoid "Sorting orther, either `asc' or `desc'"
			}
		}

    // A list of work items in their terse representation (c.f. "FullReply")
    [message ListReply]
    {
      properties=
      {
        workitem_list: sequence<record (
          workitem, [
            id: integer greaterZero "Workitem ID";
            type_id: integer greaterZero "Workitem type";
            timestamp: integer greaterZero "Creation time";
            project_id: integer greaterZero "Project Id";
            project_name: string notEmpty "Project name";
            user_id: integer greaterZero "User ID";
            user_name: string notEmpty "User name";
            ref: string notEmpty "Reference URL";
            title: string notEmpty "Descriptive title";
            is_new: boolean "Is this work item for a new item, or an existing one?";
            is_read: boolean "Did the requestor already read this workitem?"
          ])> notVoid "The list of retrieved workitems"
      }
    }
    
    // Retrieves a list of projects where there are new workitems for the user
    [message NewActivity extends=Aranea::Default::Session]
    {
    }

    // Reply to "NewActivity"
    [message NewActivityReply]
    {
      properties=
      {
        project_id_list: sequence<integer> notVoid "list of projects where there are new workitems for the user sending the request."
      }    
    }
    
    // retrieve message
    [message Retrieve extends=Aranea::Default::Session]
    {
      properties=
      {
        workitem_id_list: sequence<integer> notVoid "List of Workitem IDs for which to retrieve details."
      }
    }

    // A list of work items with full details (c.f. "Reply")
    [message RetrieveReply]
    {
      properties=
      {
        workitem_list: sequence<record (
          full_workitem, [
            id: integer greaterZero "Workitem ID";
            type_id: integer greaterZero "Workitem type";
            timestamp: integer greaterZero "Creation time";
            project_id: integer greaterZero "Project Id";
            project_name: string notEmpty "Project name";
            user_id: integer greaterZero "User ID";
            user_name: string notEmpty "User name";
            ref: string notEmpty "Reference URL";
            title: string notEmpty "Descriptive title";
            // Here the extended details begin
            // Note: these are optional, and depend on the value of "type_id"
            //    As integers aren't nullable, we use 0 (zero) 
            revision: integer greaterEqualZero;
            previous_revision: integer greaterEqualZero;
            diff: string;
            comment_text: string;
            is_new: boolean;
            comment_type: integer greaterEqualZero;
            log: string;
              // issues
            tags: sequence<string> "List of issue tags";
            project_issue_id: integer greaterEqualZero;
            deadline: integer greaterEqualZero "Deadline timestamp";
            work_amount: integer greaterEqualZero "Measured in number of days";
            description: string;
            attachments: sequence<record(
              issue_attachment, [
                issue_attachment_id: integer greaterZero;
                file_name: string notEmpty;
                description: string
              ])> "List of issue attachments";
              // release
            release_id: integer greaterEqualZero;
            release_version: string;
            release_description: string;
            release_files: sequence<record(
              release_file, [
                name: string;
                platform: string
              ])> "List of files with [name, platform]";
            is_private: boolean
          ])> notVoid "The list of retrieved workitems"
      }
    }

		// set read status project message
		[message SetReadStatusProject extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				read_status: boolean "Read status"
			}
		}
		
		// set read status message
		[message SetReadStatus extends=Aranea::Default::Session]
		{
			properties=
			{
				workitem_id: integer greaterZero "Workitem id"
				read_status: boolean "Read status"
			}
		}
		
		// workitem mail message
		[message Mail]
		{
			properties=
			{
				workitem_id: integer greaterZero "Workitem id"
			}
		}
		
		// workitem mail reply message
		[message MailReply]
		{
			properties=
			{
				subject: string notVoid "Mail subject"
				body: string notVoid "Mail body"
				sender: string notVoid "Mail sender name"
				addresses: sequence<string> notVoid "Mail addresses"
			}
		}
	}
	
	[namespace Issue]
	{
		[message Add extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				title: string notEmpty "Issue title"
				description: string notVoid "Issue description"
				tags: string notVoid "Tags of the issue"
				is_private: boolean "Is the issue private?"
				is_internal: boolean "Is this an internal message?"
				deadline: integer greaterEqualZero "The deadline of the issue"
				work_amount: integer greaterEqualZero "The estimated amount of work to fix the issue"
			}
		}

		[message AddReply]
		{
			properties=
			{
				project_issue_id: integer greaterEqualZero
			}
		}
		
		[message AddStorageReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero
				user: string notEmpty
				project_id: integer greaterEqualZero
				project_name: string notEmpty
				project_issue_id: integer greaterEqualZero
			}
		}	
	
		// issue add attachment message
		// TODO messages should be immutable, which would allow this to be a normal message
		// TODO: for now, this is generated... --B.Herlig, 2009-06-30
		[message AddAttachment extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				project_issue_id: integer greaterZero "Issue id"
				file_name: string notEmpty "File name"
				description: string notEmpty "Description of the file"
				is_internal: boolean "Is this an internal message?"
			}
		}

		[message AddAttachmentStorageReply]
		{
			properties=
			{
				issue_attachment_id: integer "ID of the newly added attachment."
			}
		}

		// issue add subscription message
		[message AddSubscription extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "The project id"
				project_issue_id: integer greaterZero "The issue id"
			}
		}

		// issue comment message
		[message Comment extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterEqualZero "id of the project"
				project_issue_id: integer greaterEqualZero "id of the issue in this project"
				description: string notVoid "Issue description"
				is_internal: boolean "is this an internal message?"
				
				is_extended: boolean "`true' = The message contains new tags which are to be set in the new issue revision'; `false' = Do not change the tags which means that the tags of the previous revision are used"
				deadline: integer greaterEqualZero "The deadline of the issue"
				work_amount: integer greaterEqualZero "Estimated amount of work to fix the issue"
				tags: string notVoid "Tags"
			}				
		}
		
		// The storage node's reply message upon adding a comment.
		// As the comment may have changed tags, this reply is somewhat verbose, as the
		//   frontend needs to be updated.
		[message CommentReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "The newly added workitem's ID."
				user: string notEmpty "Username related to the issue's comment."
				project_id: integer greaterEqualZero "ID of the project."
				project_name: string notEmpty "Projectname"
				project_issue_id: integer greaterEqualZero "ID of the issue in this project"
				title: string notVoid
				tags: string notVoid "Tags"
			}				
		}

		// delete an issue 
		[message Delete extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				project_issue_id: integer greaterEqualZero "Issue ID"
				is_internal: boolean "Is this an internal message, i.e. does the frontend need to be updated?"
			}
		}

		// Delete issue: the storage node acknowledges the process, and returns the projectname for updating the frontend.
		[message DeleteStorageReply extends=Aranea::General::Status]
		{
			properties=
			{
				project_name: string "Project name to which the deleted issue belonged to"
			}
		}

		// issue list messasge
		[message List extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
			}
		}
		
		// issue list reply messasge
		[message ListReply]
		{
			properties=
			{
				issue_list: map<record(issue, [
					issue_id: integer;
					creation_time: integer;
					last_modified: integer;
					user: string;
					title: string;
					deadline: integer;
					work_amount: integer;
					tags: string
				])> notVoid "Issue list"
			}
		}
		
		// issue list changed message
		[message ListChanged extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				date: integer greaterEqualZero "Unix timestamp, all issues changed after this time will be returned" 
			}
		}
		
		// issue list tags messasge
		[message ListTags extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
			}
		}
		
		// issue list tags reply messasge
		// TODO switch to sequence<string>
		[message ListTagsReply]
		{
			properties=
			{
				tag_list: sequence<string> notVoid "Tags list"
			}
		}
		
		// Remove all attachments of an issue
		[message RemoveAllAttachments extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				project_issue_id: integer greaterZero "Issue id"
				is_internal: boolean "Is this an internal message?"
			}
		}
		
		// Remove all attachments of an issue
		[message RemoveAllAttachmentsStorageReply extends=Aranea::General::Status]
		{
			properties=
			{
				project_name: string "Project name to which the removed attachments belonged to"
				files: sequence<string> "File names of the removed attachments"
			}
		}
		
		// issue remove attachement message
		[message RemoveAttachment extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				project_issue_id: integer greaterZero "Issue id"
				file_name: string notEmpty "File name"
				is_internal: boolean "Is this an internal message?"
			}
		}
				
		// issue retrieve messasge
		[message Retrieve extends=Aranea::Default::Session]
		{
			properties=
			{
				issue_id: integer greaterZero "Issue id"
				project: integer greaterZero "Project id"
			}
		}
		
		// issue retrieve reply message		
		[message RetrieveReply]
		{
			properties=
			{
				creation_time: integer greaterZero "Creation time"
				last_modified: integer greaterEqualZero "Last modification time"
				user: string notEmpty "User who created the issue" 
				title: string notEmpty "Issue title"
				tags: string notVoid "Tags of the issue"
				is_private: boolean "Is the issue private?"
				deadline: integer greaterEqualZero "the deadline of the issue"
				work_amount: integer greaterEqualZero "the estimated amount of work to fix the issue"
				revisions: sequence<record(revision, [
					creation_time:integer;
					user: string;
					text: string;
					text_type: integer;
					tags: string])> "List of revisions with [creation_time, text, tags]"
			}
		}

		// issue retrieve attachments message
		[message RetrieveAttachments extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				project_issue_id: integer greaterZero "Issue id"
			}
		}
		
	    // issue retrieve attachments reply messasge
	    [message RetrieveAttachmentsReply]
	    {
	      properties=
	      {
	        issue_attachment_list: sequence<record(issue_attachment, [
	          issue_attachment_id: integer;
	          file_name: string notEmpty;
	          description: string notVoid
	        ])> notVoid "Issue attachments list"
	      }
	    }
		
		// issue remove subscription message
		[message RemoveSubscription extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "The project id"
				project_issue_id: integer greaterZero "The issue id"
			}
		}
		
		// issue retrieve planning data message
		[message RetrievePlanningData extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "The project id"
				project_issue_id: integer greaterZero "The issue id"
			}
		}
		
		// issue retrieve planning data reply message
		[message RetrievePlanningDataReply]
		{
			properties=
			{
				deadline: integer greaterEqualZero "The deadline of the issue"
				work_amount: integer greaterEqualZero "The estimated amount of work to fix the issue"
			}
		}
		
		// issue search message
		[message Search extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				search_criteria: map<string> notVoid "The search query (maps issue field names to the desired values)"
			}
		}

		// issue update message
		[message Update extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				project_issue_id: integer greaterZero "Issue id"
				title: string notEmpty "Issue title"
				description: string notVoid "Issue description"
				tags: string notVoid "Tags of the issue"
				is_private: boolean "Is the issue private?"
				is_internal: boolean "Is this an internal message?"
				deadline: integer greaterEqualZero "the deadline of the issue"
				work_amount: integer greaterEqualZero "the estimated amount of work to fix the issue"
			}
		}
		
		[message UpdateReply]
		{
			properties=
			{
				project_issue_id: integer greaterZero "Issue id"
			}
		}
		
		// The storage node's reply upon Updating an issue.
		[message UpdateStorageReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero "The updated workitem's ID."
				user: string notEmpty "Username related to the issue."
				project_id: integer greaterEqualZero "ID of the project."
				project_name: string notEmpty "Projectname"
				project_issue_id: integer greaterEqualZero "ID of the issue in this project"
			}
		}

		// issue id message, implemented using the standard available messagse
//		[message Id none]
//		{}
	}
	
	[namespace Project]
	{

		[message ChangeDescription extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				description: string notEmpty "New description"
			}
		}

		[message ChangeGroup extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project ID"
				user: string notEmpty "User name"
				group: integer greaterEqualZero "Access group ID"
			}
		}
		
		[message ChangeInformation extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				informations: sequence<record(information, [
					information_type: string;
					information_value: string
				])> notVoid "List of informations with [information_type, information_value]"
			}
		}
		
		[message ChangeLogo extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				logo: string notEmpty "New logo"
			}
		}
		
		[message ChangeSettings extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				settings: sequence<record(setting, [
					setting_type: string;
					setting_value: string
				])> notVoid "List of informations with [setting_type, setting_value]"
			}
		}

	    [message ChangeType extends=Aranea::Default::Session]
	    {
	      properties=
	      {
	        project_id: integer "The affected project's ID."
	        project_type: integer greaterEqualZero "Project type, e.g. 'Open Source'."
	        rcs_type: integer greaterEqualZero "The type of the project's revision control system"
	        visibility: integer greaterEqualZero "Project visibility, e.g. hidden."
	      }
	    }
    		
		[message Create extends=Aranea::Default::Session]
		{
			properties=
			{
				name: string notEmpty "Project name"
				description: string notEmpty "Project description"
				owner_name: string "Name of the user who should own the project"
				project_type: integer greaterEqualZero "The project's type"
				rcs_type: integer greaterEqualZero "The type of the project's revision control system"
				project_visibility: integer greaterEqualZero "Is the project visible?"
			}
		}

		[message CreateReply]
		{
			properties=
			{
				project_id: integer greaterEqualZero "ID of the newly created project"
			}
		}
		
		[message Internal]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message ListAllInternal]
		{
			properties=
			{
				show_hidden: boolean "Show all projects including hidden projects?"
			}
		}
		
		[message ListAll extends=Aranea::Default::Session]
		{
			properties=
			{
				show_hidden: boolean "Show all projects including hidden projects?"
			}
		}
		
		[message ListBookmarkers extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message ListCommunities extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message List]
		{
			properties=
			{
				project_list: map<record(project, [
					project_id: integer;
					name: string;
					pretty_name: string;
					summary: string;
					logourl: string;
					programming_language: string;
					operating_system: string;
					license: string;
					category: string
				])> notVoid "Project list"
			}
		}
		
		[message ListOfUser extends=Aranea::Default::Session]
		{
			properties=
			{
				user: string notEmpty "Name of user we want a project list"
			}
		}
		
		[message ListOfUserReply]
		{
			properties=
			{
				project_list: map<record(project_name_and_gid, [
					project_name: string;
					group: integer
				])> notVoid "Project list"
			}
		}
		
		[message ListPartialInternal]
		{
			properties=
			{
				show_hidden: boolean "Show all projects including hidden projects?"
				start_index: integer greaterEqualZero "The start index into the project list"
				count: integer greaterZero "The number of projects to be returned (starting at 'count')"
				sort_column: string notEmpty "The sort column, must match a database column"
				sort_order: string notEmpty "Sorting orther, either `asc' or `desc'"
			}
		}
		
		[message ListPartial extends=Aranea::Default::Session]
		{
			properties=
			{
				show_hidden: boolean "Show all projects including hidden projects?"
				start_index: integer greaterEqualZero "The start index into the project list"
				count: integer greaterZero "The number of projects to be returned (starting at 'count')"
				sort_column: string notEmpty "The sort column, must match a database column"
				sort_order: string notEmpty "Sorting orther, either `asc' or `desc'"
			}
		}
		
		[message ListRepositories extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message ListRepositoriesReply]
		{
			properties=
			{
				repositories: sequence<string> "The list of the project's repositories"
				repository_limit: integer greaterEqualZero "The maximum number of repositories for this project"
			}
		}
		
		[message AddRepository extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				repository_name: string notEmpty "Name of the repository to add"
			}
		}
		
		[message AddRepositoryReply]
		{
			properties=
			{
				project_name: string "The name of the project the repository was added to"
				is_open_source: boolean "Denotes whether the project is open source or not"
			}
		}
		
		[message RemoveRepository extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				repository_name: string notEmpty "Name of the repository to remove"
			}
		}
		
		[message Members extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project ID"
				group: integer greaterEqualZero "Access group ID"
			}
		}
		
		[message ID extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message Remove extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message Reply]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				name: string notEmpty "Name"
				logo: string notVoid "Logo"
				project_type: integer greaterEqualZero "The project's type"
			}
		}
		
		[message RequestAdd extends=Aranea::Default::Session]
		{
			properties=
			{
				name: string notEmpty "Name"
				description: string notEmpty "Project description"
				project_type: integer greaterEqualZero "The project's type"
				rcs_type: integer greaterEqualZero "The type of the project's revision control system"
				project_visibility: integer greaterEqualZero "Is the project visible?"
				message: string notVoid "Project request message"
			}
		}
		
		[message RequestRetrieve extends=Aranea::Default::Session]
		{
			properties=
			{
				request_project_name: string notEmpty "Request project name"
			}
		}
		
		[message RequestRetrieveReply]
		{
			properties=
			{
				request_id: integer greaterZero "Request ID"
				user_name: string notEmpty "User name"
				user_email: string notEmpty "User Email"
				name: string notEmpty "Project name"
				description: string notVoid "Description"
				project_type: integer greaterEqualZero "The project's type"
				rcs_type: integer greaterEqualZero "The type of the project's revision control system"
				project_visibility: integer greaterEqualZero "Is the project visible?"
				message: string notVoid "Project request message"
			}
		}
		
		[message RetrieveID extends=Aranea::Default::Session]
		{
			properties=
			{
				project_name: string notEmpty "Project name"
			}
		}
		
		[message RetrieveIdReply]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message RetrieveInformation extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message RetrieveInformationReply]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				short_description: string
				description: string
				programming_language: string
				operating_system: string
				license: string
				category: string				
			}
		}
		
		[message RetrieveSettings extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
			}
		}
		
		[message RetrieveSettingsReply]
		{
			properties=
			{
				project_id: integer greaterZero "Project ID"
				name: string
				logo: string
				project_type: integer greaterZero
				rcs_type: integer greaterEqualZero "The type of the project's revision control system"
				project_visibility: integer greaterEqualZero "Is the project visible?"
				svn_path_doc: string
				project_pretty_name: string
				creation_time: integer				
			}
		}
		
		[message RetrieveStatisticsInternal]
		{
			properties=
			{
			
			}
		}
		
		[message RetrieveStatistics extends=Aranea::Default::Session]
		{
		}
		
		[message RetrieveStatisticsReply]
		{
			properties=
			{
				project_count: integer greaterEqualZero "The number of projects (excluding hidden projects, used for the project list)"
				open_source_count: integer greaterEqualZero "The number of open-source projects (excluding hidden projects )"
				project_count_hidden: integer greaterEqualZero "The number of hidden projects"
				open_source_count_hidden: integer greaterEqualZero "The number of hidden open-source projects"
				user_count: integer greaterEqualZero "The number of active origo users"
				recent_projects: string notVoid "The 5 recently created projects (names) separated by comma"			
			}
		}
	}

	[namespace Release]
	{
		// release add message
		[message Add extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				name: string notEmpty "Release name"
				description: string notVoid "Release description"
				version: string notEmpty "Release version"
				files: sequence<record(add_file, [ name: string; platform: string ])> notEmpty "List of files with [name, platform]"
			}
		}
		
		[message AddStorageReply]
		{
			properties=
			{
				workitem_id: integer greaterEqualZero
				project_name: string notEmpty
				user_name: string notEmpty
				release_id: integer greaterEqualZero
			}
		}

		// release delete message
		[message Delete extends=Aranea::Default::Session]
		{
			properties=
			{
				project_id: integer greaterZero "Project id"
				release_id: integer greaterZero "Release id"
			}
		}

		// release file move config request message
		[message FileMoveConfigRequest extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
			}
		}

		// release list internal message
		[message ListInternal]
		{
			properties=
			{
				project: integer greaterZero "Project id"
			}
		}

		// release list message
		[message List extends=Aranea::Default::Session]
		{
			properties=
			{
				project: integer greaterZero "Project id"
			}
		}

		// release list reply message
		[message ListReply]
		{
			properties=
			{
				release_list: map<record(release, [
					project: integer;
					creation_time: integer;
					name: string;
					description: string;
					version: string;
					files: sequence<
						record(list_file, [ name: string; platform: string ])
					>
				])> notVoid "Release list"
			}
		}

		// release retrieve internal message
		[message RetrieveInternal]
		{
			properties=
			{
				release_id: integer greaterZero "Release id"
			}
		}

		// release retrieve message
		[message Retrieve extends=Aranea::Default::Session]
		{
			properties=
			{
				release_id: integer greaterZero "Release id"
			}
		}

		// release retrieve reply message
		[message RetrieveReply]
		{
			properties=
			{
				project: integer greaterZero "Project id"
				creation_time: integer greaterZero "Creation time"
				name: string notVoid "Release name"
				description: string notVoid "Release description"
				version: string notVoid "Release version"
				files: sequence<record(retrieve_file, [ name: string; platform: string])> notEmpty "List of files with [name, platform]"
			}
		}

	}
	
	[namespace RRD]
	{
		// message to create a rrd
		[message Create]
		{
			properties=
			{
				filename: string notEmpty "File name"
				start_time: integer greaterEqualZero "Start time, 0 for default (now - 10s)"
				step: integer greaterEqualZero "Step, 0 for default (300)"
				datasource_definition: sequence<string> notEmpty "Datasource definition as specified by rrdtool"
				round_robin_archives: sequence<string> notEmpty "RRA definitions as specified by rrdtool"
			}
		}
		
		// message to update a rrd
		[message Update]
		{
			properties=
			{
				filename: string notEmpty "File name"
				template: string "Datasource template or Void if not needed"
				update: sequence<string> notEmpty "Update time/values as specified by rrdtool"
			}
		}
	}
	
	[namespace Statistics]
	{
		// message to create rrd files for a project
		[message Create]
		{
			properties=
			{
				project_name: string notEmpty "Project name"
			}
		}

		// message to update statistics
		[message Update]
		{
			properties=
			{}
		}
		
		// message to query workitem stats
		[message RetrieveWorkitem]
		{
			properties=
			{}
		}
		
		// message reply for workitem stats
		[message RetrieveWorkitemReply]
		{
			properties=
			{
				stats: map<record(workitem_stat, [
					total: integer;
					issue: integer;
					release: integer;
					commit: integer;
					wiki: integer;
					blog: integer;
					comment: integer
				])> notVoid "Statistics per project."
			}
		}

		// message to query issue stats
		[message RetrieveIssue]
		{
			properties=
			{}
		}
		
		// message reply for issue stats
		[message RetrieveIssueReply]
		{
			properties=
			{
				stats: map<record(issue_stat, [ open: integer; closed: integer])> notVoid "Statistics per project."
			}
		}
	}
}