<?php
/*******************************************************************************
 * Copyright (c) 2005,2015 Eclipse Foundation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Christopher Guindon (Eclipse Foundation) - initial API and implementation
 *    Donald Smith (Eclipse Foundation)
 *******************************************************************************/

  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/classes/membership/membership.class.php");

  $App = new App();
  $Nav = new Nav();
  $Menu = new Menu();
  $Membership = New Membership();
  include($App->getProjectCommon());
  $App->preventCaching();

  # Begin: page-specific settings.  Change these.
  $pageTitle  = "Eclipse Membership";
  $pageKeywords = "Eclipse Membership profile page";
  $pageAuthor = "Christopher Guindon";

  require_once("../projects/classes/Project.class.php");
  $id = NULL;
  if (isset($_GET['member_id'])) {
    $id = $_GET['member_id'];
  }
  $include_file = $App->getScriptName();
  $profile = array();

  if ($Membership->setId($id)) {
    $profile = $Membership->fetchProfile();
  }

  if (empty($profile)) {
    $include_file = "showMemberInvalid.php";
    $profile['name'] = 'INVALID MEMBER ID';
  }
  else {
    $pageTitle .= " > " . $profile['name'];
  }

    // Place your html content in a file called content/en_pagename.php
  ob_start();
  include("content/en_" . $include_file);
  $html = ob_get_clean();

  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/breadcrumbs.class.php");
  $Breadcrumb = new Breadcrumb();
  # remove last crumb since it represents this _projectCommon page.
  $Breadcrumb->removeCrumb($Breadcrumb->getCrumbCount() -1);
  $Breadcrumb->addCrumb("Eclipse Membership", "/membership/exploreMembership.php", "_self");
  $Breadcrumb->addCrumb($profile['name'], NULL, NULL);

  # Generate the web page
  $App->generatePage("solstice", $Menu, NULL, $pageAuthor, $pageKeywords, $pageTitle, $html, $Breadcrumb);
?>