#!/usr/bin/python
#
# Copyright (C) 2007, 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

__author__ = 'Gunjan Sharma <gunjansharma@google.com>'

import getopt
import getpass
import sys
import time
import atom
import atom.data
import gdata.apps.multidomain.client
import gdata.apps.organization.service
import gdata.apps.service
import gdata.client
import gdata.contacts.client
import gdata.contacts.data
import gdata.contacts.service
import gdata.sites.client
import gdata.sites.data

#The title for the site
ORG_SITE_TITLE = 'Organization Hierarchy'
#Title for the users site
USER_SITE_TITLE = 'Users'
#The template URI for a site
URI = 'https://sites.google.com/a/%s/%s/'
#Description for the sites
DESCRIPTION = 'Under Construction'
#Theme for the sites
THEME = 'slate'
#Header for the new webpages
HTML_HEADER = ('<html:div xmlns:html="http://www.w3.org/1999/xhtml">'
               '<html:table cellspacing="0" class='
               '"sites-layout-name-one-column sites-layout-hbox"><html:tbody>'
               'html:tr><html:td class="sites-layout-tile '
               'sites-tile-name-content-1">')
#Footer for the new webpages
HTML_FOOTER = '</html:td></html:tr></html:tbody></html:table></html:div>'
#The template string for each user's html page
TEMPLATE_USER_HTML = ('<h2>Name:</h2><p>%s</p><h2>Gender:</h2><p> %s</p>'
                      '<h2>Address:</h2><p>%s</p><h2>Email:</h2><p>%s</p>')


class OrgUnitAddressBook(object):
  """Creates organization unit sites from the domain."""

  def __init__(self, email, password, domain):
    """Constructor for the OrgUnitSites object.

    Takes an email, password and domain to create a site map corresponding
    to the organization units in the domain.

    Args:
      email: [string] The email address of the admin.
      password: [string] The password corresponding to the admin account.
      domain: [string] The domain for which sites are to be made.

    Returns:
      A OrgUnitSites object used to run the site making.
    """
    source = 'Making sites corresponding to org units'
    self.domain = domain
    # Create sites object
    self.sites_client = gdata.sites.client.SitesClient(source=source,
                                                       domain=domain)
    self.sites_client.ClientLogin(email, password, self.sites_client.source);
    #Get the sites feed
    self.all_site_feed = self.sites_client.GetSiteFeed()
    
    # Create google contacts object
    self.profiles_client = gdata.contacts.client.ContactsClient(domain=domain)
    self.profiles_client.client_login(email, password, 'cp', service='cp')

    # Create an Organization Unit Client
    self.org_unit_client = gdata.apps.organization.service.OrganizationService(
                                 email=email, domain=domain, password=password)
    self.org_unit_client.ProgrammaticLogin()
    customer_id_set = self.org_unit_client.RetrieveCustomerId()
    self.customer_id = customer_id_set['customerId']

  def _GetSiteName(self, site_title):
    """Returns the corresponding site_name. This is needed since the site name
       isn't the same as the title.

    Args:
      site_title: [string] The title for a site.

    Returns:
      A string which is the corresponding site_name.
    """
    site_name = site_title.replace(' ', '-')
    site_name = site_name.lower()
    return site_name
  
  def _GetSiteURI(self, site_title):
    """Returns the corresponding uri to the site.
       Needed to get the link to a particular user page.

    Args:
      site_title: [string] The title for a site.

    Returns:
      A string which is the corresponding site's URI.
    """
    uri = URI % (self.domain, self._GetSiteName(site_title))
    return uri
    
  def _CreateSite(self, site_title, description=DESCRIPTION, theme=THEME):
    """Creates a site with the site_title, if it not already exists.

    Args:
      site_title: [string] The title for a site.
      description: [string] The description for the site.
      theme: [string] The theme that should be set for the site.

    Returns:
      A Content feed object for the created site.
    """
    site_entry = None
    site_found = False
    site_name = self._GetSiteName(site_title)    
    for site in self.all_site_feed.entry:
      if site.site_name.text == site_name:
        site_found = True
        site_entry = site
        break
    if site_found == False:
      try:
        site_entry = self.sites_client.CreateSite(site_title,
                          description=description, theme=theme)
      except gdata.client.RequestError, error:
        print error
    self.sites_client.site = site_name
    return site_entry

  def _DeleteAllPages(self):
    '''Deletes all the pages in a site except home'''
    feed_uri = self.sites_client.make_content_feed_uri()
    while feed_uri:
      feed = self.sites_client.GetContentFeed()
      for entry in feed.entry:
        if entry.page_name.text != 'home':
          self.sites_client.Delete(entry)
      feed_uri = feed.FindNextLink()

  def _GetUsersProfileFeed(self):
    """Retrieves all the user's profile.

    Returns:
      A Dictionary of email address to ContentEntry objects
    """    
    profiles = []
    feed_uri = self.profiles_client.GetFeedUri('profiles')
    while feed_uri:
      feed = self.profiles_client.GetProfilesFeed(uri=feed_uri)
      profiles.extend(feed.entry)
      feed_uri = feed.FindNextLink()
    
    profiles_dict = {}
    for profile in profiles:
      for email in profile.email:
        if email.primary and email.primary == 'true':
          profiles_dict[email.address] = profile
          break
          
    return profiles_dict
    
  def _CreateUserPageHTML(self, profile):
    """Creates HTML for a user profile.

    Args:
      profile: [gdata.contacts.data.ProfileEntry] It is the profile of the user
                                                  whose HTML has to be created.

    Returns:
      A String which is the HTML code.
    """    
    address_string = ''
    email_string = ''
    for address in profile.structured_postal_address:
      address_string = '%s<li>%s</li><br />' % (address_string, address)
    for email in profile.email:
      if email.primary and email.primary == 'true':
        email_string = '%s<li>%s</li><br />' % (email_string, email.address)
    
    new_html = TEMPLATE_USER_HTML % (profile.name.full_name.text,
                         str(profile.gender), address_string, email_string)
    
    return HTML_HEADER + new_html + HTML_FOOTER

  def _GetUserPageName(self, user_email):
    """Creates a page name for a particular user depending on the
       email address.

    Args:
      user_email: [string] The email address of the user.

    Returns:
      A String which defines the user page name.
    """
    user_page_name = user_email.replace('@', '-')
    user_page_name = user_page_name.replace('.', '_')
    user_page_name = user_page_name.lower()
    return user_page_name

  def _CreateUserPages(self):
    """Makes all the user pages"""
    
    entry = self._CreateSite(USER_SITE_TITLE)

    #Delete all the pages 
    self._DeleteAllPages()
    
    users_profile = self._GetUsersProfileFeed()
    users = self.org_unit_client.RetrieveAllOrgUsers(self.customer_id)
    for user in users:
      user_email = user['orgUserEmail']
      user_profile = users_profile[user_email]
      new_html = self._CreateUserPageHTML(user_profile)  
      user_page_name = self._GetUserPageName(user_email)
      
      self.sites_client.CreatePage('webpage', user_profile.name.full_name.text,
                                   html=new_html, page_name=user_page_name)
  
  def _GetOrgUnitPageHTML(self, path):
    """Creates HTML for a Org Unit Page.

    Args:
      profile: [string] Path of the Org Unit.

    Returns:
      A String which is the HTML code.
    """
    
    domain_users = self.org_unit_client.RetrieveOrgUnitUsers(self.customer_id,
                                                             path)
    new_html = '<p>'
    for user in domain_users:
      user_email = user['orgUserEmail']
      user_page_name = self._GetUserPageName(user_email)
      site_uri = self._GetSiteURI(USER_SITE_TITLE)
      new_html = '%s<li><a href="%s">%s</a></li><br />' % (new_html,
                                         site_uri + user_page_name, user_email)
    new_html = new_html + '</p>'
    return HTML_HEADER + new_html + HTML_FOOTER
  
  def _SetOrgSiteHomePage(self):
    """Sets up the home page for Org Unit Site"""
    new_html = self._GetOrgUnitPageHTML('/')
    home_path = self._GetUnitPath()
    home_feed = self.sites_client.GetContentFeed(uri=home_path)
    home_feed.entry[0].title.text = self.domain
    home_feed.entry[0].content.html = new_html
    self.sites_client.Update(home_feed.entry[0])
  
  def _GetUnitPath(self, path=None):
    """Returns path to the parent unit

    Args:
      parent_path: [string] Path of the Parent Org Unit.

    Returns:
      A String which is the path to the parent.
    """
    path_uri = '%s?path=/%s'
    if path:
      path = path.replace('+', '-')
      path = path.lower()
      path = 'home/' + path
    else:
      path = 'home'
  
    uri = path_uri % (self.sites_client.MakeContentFeedUri(), path)
    return uri
  
  def _CreateOrgUnitPages(self):
    """Creates all the org unit pages"""
    
    entry = self._CreateSite(ORG_SITE_TITLE)    
    #Delete all the pages 
    self._DeleteAllPages()
    
    self._SetOrgSiteHomePage()
    
    orgUnits = self.org_unit_client.RetrieveAllOrgUnits(self.customer_id)
    for unit in orgUnits:
      parent_uri = self._GetUnitPath(unit['parentOrgUnitPath'])      
      parent_feed = self.sites_client.GetContentFeed(uri=parent_uri)
  
      new_html = self._GetOrgUnitPageHTML(unit['orgUnitPath'])      
      self.sites_client.CreatePage('webpage', unit['name'], html=new_html,
                                   parent=parent_feed.entry[0])

  def Run(self):
    """Controls the entire flow of the sites making process"""
    
    print 'Starting the process. This may take few minutes.'
    print 'Creating user pages...'
    self._CreateUserPages()
    print 'User pages created'
    print 'Creating Organization Unit Pages'
    self._CreateOrgUnitPages()
    print 'Your website is ready, visit it at: %s' % (self._GetSiteURI(
                                                      ORG_SITE_TITLE))


def main():
  """Runs the site making module using an instance of OrgUnitAddressBook"""
  # Parse command line options
  try:
    opts, args = getopt.getopt(sys.argv[1:], '', ['email=', 'pw=', 'domain='])
  except getopt.error, msg:
    print ('python org_unit_sites.py --email [emailaddress] --pw [password]'
           ' --domain [domain]')
    sys.exit(2)

  email = ''
  password = ''
  domain = ''
  # Parse options
  for option, arg in opts:
    if option == '--email':
      email = arg
    elif option == '--pw':
      password = arg
    elif option == '--domain':
      domain = arg

  while not email:
    email = raw_input('Please enter admin email address (admin@example.com): ')
  while not password:
    sys.stdout.write('Admin Password: ')
    password = getpass.getpass()
    if not password:
      print 'Password cannot be blank.'
  while not domain:
    username, domain = email.split('@', 1)
    choice = raw_input('You have not given us the domain name. ' +
                        'Is it %s? (y/n)' % (domain))
    if choice == 'n':
      domain = raw_input('Please enter domain name (domain.com): ')

  try:
    org_unit_address_book = OrgUnitAddressBook(email, password, domain)
  except gdata.service.BadAuthentication:
    print 'Invalid user credentials given.'
    return

  org_unit_address_book.Run()


if __name__ == '__main__':
  main()
