# emacs-mode: -*- python-*-
from BaseConfigHandler import BaseConfigHandler
import OCWException
import published
import DocumentTemplate
from HTMLComponents import HTMLDirectoryTree, HTMLTable
from string import replace, find, split, strip, join, index
import re
import os
import cStringIO
import cPickle
import select
import stat
import sys
import tempfile
import pdb
import string
import ensimapplpath
import cmdlnpopen
import logging
import wpidn
import posixpath
from serverman.current.networkmgr import NetworkManager
from time import time, localtime, strftime
import urllib
from BaseFormChecker import BaseFormChecker
from vh3 import virthost
from vh3.modules import vhbackup as vhbackuputils
import sessionman
import traceback
from vh3.errors.vhbackup import *
from base.services.vhbackup.vhbackup_error import VhbackupError
from ftplib import FTP, error_perm
import egv
XML_ENCODING_DEFAULTS = '/etc/appliance/backup_xml.conf'
XML_ENCODING_CUSTOM = '/etc/appliance/customization/backup_xml.conf'
_waitpids = []
class execRestoreException(Exception):
    __module__ = __name__

    def __init__(self, err):
        self.err = err



class BackupFormChecker(BaseFormChecker):
    __module__ = __name__

    def valid_user_selection(self, input):
        return ('\n            if ( (elemdict["%s"] == "user") && (elemdict["%s"] == "") ) {\n                alert ("%s");\n                return false;\n            }\n            ' % (input['data_type_name'],
         input['data_user_name'],
         self.T_('You have not selected any valid user!')))




def _garbage_collect_waitpids():
    global _waitpids
    print ('waitpids: %s' % str(_waitpids))
    newpids = []
    for curr_pid in _waitpids:
        try:
            (pid, sts,) = os.waitpid(curr_pid, os.WNOHANG)
        except:
            continue
        if os.WIFEXITED(sts):
            print ('killed waitpid %d' % curr_pid)
            continue
        newpids.append(curr_pid)

    _waitpids = newpids


class vhbackupConfigHandler(BaseConfigHandler):
    __module__ = __name__

    def license_is_pro(self):
        return egv.is_pro()



    def _menuitems(self):
        return [('form_backup',
          'Backup')]


    _toolbar_tmpl = published.HTMLFile('base/common/view_menu', globals())
    _backup_schedules = {}
    _ftplist = []

    def getHelpList(self):
        raise 'subclass must implement this'



    def getHelpRole(self):
        raise 'subclass must implement this'



    def getHelpURL(self, selection):
        raise 'subclass must implement this'



    def default_ftpuser(self):
        return 'vhbackup'



    def _toolbar_html(self, REQUEST, **kw):
        m = self._menuitems()
        m2 = []
        for i in m:
            m2.append((('%s/%s' % (self.absolute_url(),
              i[0])),
             i[1]))

        kw['menuitems'] = m2
        kw['helpList'] = self.getHelpList()
        kw['helpRole'] = self.getHelpRole()
        kw['helpURL'] = self.getHelpURL(kw['selecteditem'])
        return apply(self._toolbar_tmpl, [self,
         REQUEST], kw)


    _statusbar_html = published.HTMLFile('base/common/statusbar', globals())

    def _bk_properties(self, REQUEST):
        prop = self._bk_type_properties(REQUEST)
        return prop



    def _bk_email_properties(self, REQUEST):
        backup_prop = []
        admin_email = self._get_admin_email()
        email = {'check': 'email_IDN',
         'lencheck': 1,
         'strict': 1,
         'type': 'text',
         'label': 'Email',
         'name': 'email',
         'value': admin_email}
        backup_prop.append(email)
        return backup_prop



    def _res_select_properties(self, REQUEST):
        """ this function returns a list of property dictionaries that can be 
            passed onto base/common/form in order to draw the list of files 
            on the ftp server, so that you can choose which file to restore
            When the final HTML is drawn, it looks like:
            <input type=checkbox name=file1 value=on> [filename1]
            <input type=checkbox name=file2 value=on> [filename2]

            [filename1, filename2] are stored in the session in the file_list
            variable. When the form is actually posted, we find out which 
            file was selected by examining the checkboxes that were clicked,
            and then using that, we index into the file_list session variable
            and find out the actual file name
        """
        prop = []
        session = sessionman.getSession(REQUEST)
        file_list = session['file_list']
        if file_list:
            index = 0
            for data in file_list:
                prop.append({'type': 'checkbox1',
                 'name': ('file%d' % index),
                 'value': str(index),
                 'label': self.beautify_restore_filename(data)})
                index += 1

            prop.append({'type': 'label',
             'value': self.T_('Select Options'),
             'label': ''})
            prop.append({'type': 'checkbox1',
             'name': 'recurse',
             'value': 'on',
             'label': self.T_('Enable Recurse')})
        else:
            prop.append({'type': 'label',
             'value': 'No tar files found',
             'label': ''})
        return prop



    def _bk_ftp_properties(self):
        backup_prop = []
        ftp_server = {'type': 'text',
         'name': 'ftp_server',
         'value': 'localhost',
         'label': 'FTP Server',
         'size': '20',
         'check': 'string_IDN',
         'lencheck': 1}
        ftp_username = {'type': 'text',
         'name': 'ftp_username',
         'value': self.default_ftpuser(),
         'label': 'FTP Login',
         'size': '20',
         'check': 'ftpuser'}
        ftp_password = {'type': 'password',
         'name': 'ftp_password',
         'value': '',
         'label': 'FTP Password',
         'size': '8',
         'check': 'password'}
        ftp_location = {'type': 'text',
         'name': 'ftp_location',
         'value': '',
         'label': 'FTP Location',
         'size': '20'}
        backup_prop.append(ftp_server)
        backup_prop.append(ftp_username)
        backup_prop.append(ftp_password)
        backup_prop.append(ftp_location)
        backup_prop.append({'check': 'string_IDN',
         'label': 'FTP server',
         'name': 'ftp_server'})
        backup_prop.append({'check': 'length',
         'label': 'FTP Login',
         'name': 'ftp_username'})
        backup_prop.append({'check': 'length',
         'label': 'Passwords',
         'name': 'ftp_password'})
        return backup_prop



    def _get_dropdownbox(self, list):
        dropdown = []
        for list_value in list:
            name = list_value[0]
            id = list_value[1]
            dropdown.append({'label': name,
             'value': id,
             'selected': 0})

        return dropdown



    def _set_form_value(self, prop, key, value):
        flag = 0
        for entry in prop:
            if (entry.has_key('name') and (entry['name'] == key)):
                flag = 1
                break

        if (flag == 0):
            return 
        if ((entry['type'] == 'radio') or (entry['type'] == 'select')):
            for option in entry['options']:
                if (str(option['value']) == str(value)):
                    option['selected'] = 1
                else:
                    option['selected'] = 0

            return 
        if entry.has_key('value'):
            entry['value'] = value



    def getlist_for_dropdown(self, start, end, editdata):
        list = ''
        for each_val in range(start, (end + 1)):
            if ((editdata != None) and (int(editdata) == each_val)):
                list = (list + ('<option value="%d" selected >%d' % (each_val,
                 each_val)))
            else:
                list = (list + ('<option value="%d">%d' % (each_val,
                 each_val)))

        return list



    def is_display(self):
        type = self.get_author()
        if ((type == 'useradmin') or (type == 'siteadmin')):
            return 0
        else:
            return 1



    def render_time(self, type, editdata):
        if (editdata.has_key(type) and (editdata[type] != '')):
            value = editdata[type]
        else:
            value = None
        list = ''
        if (type == 'minute'):
            list = self.getlist_for_dropdown(0, 59, value)
        if (type == 'hour'):
            list = self.getlist_for_dropdown(0, 23, value)
        if (type == 'month_day'):
            list = self.getlist_for_dropdown(1, 31, value)
        if (type == 'week_day'):
            list = self.getlist_week_dropdown(value)
        return list



    def weekdays(self):
        Weekdays = [[self.T_('Sunday'),
          7],
         [self.T_('Monday'),
          1],
         [self.T_('Tuesday'),
          2],
         [self.T_('Wednesday'),
          3],
         [self.T_('Thursday'),
          4],
         [self.T_('Friday'),
          5],
         [self.T_('Saturday'),
          6]]
        return Weekdays



    def getlist_week_dropdown(self, editdata):
        Weekdays = self.weekdays()
        wlist = ''
        for each_day in Weekdays:
            if ((editdata != None) and (int(editdata) == each_day[1])):
                wlist = (wlist + ('<option value="%s" selected> %s' % (each_day[1],
                 each_day[0])))
            else:
                wlist = (wlist + ('<option value="%s"> %s' % (each_day[1],
                 each_day[0])))

        return wlist



    def get_split_threshold_value(self, unit, value):
        multipliers = {'b': 1,
         'k': (10 ** 3),
         'm': (10 ** 6),
         'g': (10 ** 9)}
        if multipliers.has_key(unit):
            split_unit = multipliers[unit]
            return long((float(value) * long(split_unit)))
        else:
            return None



    def get_ftp_dict(self, REQUEST):
        try:
            form = REQUEST.form
            ftp_dict = {}
            ftp_dict['server'] = self.to_punycode(form['ftp_server'])
            ftp_dict['user'] = form['ftp_username']
            ftp_dict['passwd'] = form['ftp_password']
            ftp_dict['location'] = form['ftp_location']
        except:
            ftp_dict = None
        return ftp_dict



    def ftp_callback(self, line):
        self._ftplist.append(line)



    def get_backup_tar(self, ftp_dict):
        self._ftplist = []
        ftp = FTP()
        err = []
        list = []
        dirlist = None
        try:
            ftp.connect(ftp_dict['server'])
            ftp.login(ftp_dict['user'], ftp_dict['passwd'])
            ftp.cwd(ftp_dict['location'])
            try:
                dirlist = ftp.retrlines('LIST', self.ftp_callback)
            except error_perm, e:
                ftp.quit()
        except Exception, e:
            try:
                ftp.quit()
            except:
                pass
            err += [(ERROR,
              FTP_CONNECTION_ERROR,
              {'errstr': str(e)})]
            return (list,
             err)
        try:
            list_compile = re.compile('\\s+')
            dir_compile = re.compile('^[d|l]')
            for eachline in self._ftplist:
                listsplit = list_compile.split(eachline, 8)
                if ((not dir_compile.match(listsplit[0])) and (len(listsplit) == 9)):
                    list.append(listsplit[8])

        except:
            err = []
            err += [(ERROR,
              FAILED_RETREIVE_RESTORE_FILES,
              {})]
        return (list,
         err)



    def manage_restore_connect(self, REQUEST):
        """PUBLISHED"""
        errlist = []
        list = []
        email = self.puny_email(REQUEST.form.get('email', ''))
        ftp_dict = self.get_ftp_dict(REQUEST)
        if ftp_dict:
            if ftp_dict['location']:
                errlist += self.check_ftp_location(ftp_dict['location'])
            (list, err,) = self.get_backup_tar(ftp_dict)
            if err:
                errlist += err
        else:
            errlist += [(ERROR,
              NO_FTP_INFO,
              {})]
        errobj = VhbackupError(REQUEST, self.T_('Connect to Backup Server'))
        if errlist:
            errobj.pushlist(errlist)
            url = 'form_restore_ftp'
        else:
            session = sessionman.getSession(REQUEST)
            session['file_list'] = list
            session['ftp_dict'] = ftp_dict
            session['email'] = email
            send_email_msg = [self.T_('Connect completed')]
            errobj.errlist = send_email_msg
            url = 'form_select_restore'
        REQUEST.RESPONSE.redirect(url)



    def check_ftp_location(self, location):
        err = []
        ftp_compile = re.compile('^[./]+$')
        if ftp_compile.match(location):
            err += [(ERROR,
              INVALID_FTP_LOCATION,
              {})]
        return err



    def backup_cmdCallBack(self, data, p, out, err):
        try:
            outputlist = [out,
             err]
            outputlist[(p - 1)].write(data)
        except:
            import traceback
            traceback.print_exc(file=sys.stderr)



    def manage_restore(self, REQUEST):
        """ PUBLISHED """
        ret = 0
        errlist = []
        session = sessionman.getSession(REQUEST)
        if session.has_key('email'):
            email = session['email']
        if session.has_key('ftp_dict'):
            ftp_dict = {}
            ftp_dict['ftp'] = session['ftp_dict']
        else:
            ret = 1
            errlist += [(ERROR,
              NO_FTP,
              {})]
        files = REQUEST.form
        if files.has_key('recurse'):
            recurse = 1
            del files['recurse']
        else:
            recurse = 0
        if (not files):
            ret = 1
            errlist += [(ERROR,
              NO_RESTORE_SELECT,
              {})]
        if (not ret):
            urls = []
            files = [ session['file_list'][int(x[4:])] for x in files ]
            for each_file in files:
                if (ftp_dict['ftp']['location'] == ''):
                    url = ('ftp://%s:%s@%s/%s' % (ftp_dict['ftp']['user'],
                     ftp_dict['ftp']['passwd'],
                     ftp_dict['ftp']['server'],
                     each_file))
                elif re.match('/', ftp_dict['ftp']['location']):
                    url = ('ftp://%s:%s@%s/%s/%s' % (ftp_dict['ftp']['user'],
                     ftp_dict['ftp']['passwd'],
                     ftp_dict['ftp']['server'],
                     ftp_dict['ftp']['location'],
                     each_file))
                else:
                    ftp_dict['ftp']['location'] = ('/%s' % ftp_dict['ftp']['location'])
                    url = ('ftp://%s:%s@%s/%s/%s' % (ftp_dict['ftp']['user'],
                     ftp_dict['ftp']['passwd'],
                     ftp_dict['ftp']['server'],
                     ftp_dict['ftp']['location'],
                     each_file))
                urls.append(url)

            role_type = self.get_author()
            if (role_type == 'appliance'):
                role_identifier = virthost.ROLE_APPLIANCE
            elif (role_type == 'reselleradmin'):
                role_identifier = virthost.ROLE_RESELLER
            elif (role_type == 'siteadmin'):
                role_identifier = virthost.ROLE_SITEADMIN
            elif (role_type == 'useradmin'):
                role_identifier = virthost.ROLE_SITEUSER
            if (role_type == 'useradmin'):
                user_identifier = self._get_effective_user()
                domain = self._virtdomain()
                user_identifier = ('%s@%s' % (user_identifier,
                 domain))
            elif (role_type == 'siteadmin'):
                user_identifier = self._siteIndex()
            elif (role_type == 'reselleradmin'):
                user_identifier = self._get_effective_user()
            else:
                user_identifier = self._get_effective_userid(REQUEST)
            if (user_identifier == 0):
                user_identifier = None
            role = [role_identifier,
             user_identifier]
            services = []
            merge = 1
            key = None
            mail_info = self.data_for_email(None, 'restore')
            _garbage_collect_waitpids()
            pid = os.fork()
            if (pid == 0):
                self.call_backend_import(urls, services, role, merge, recurse, key, email, mail_info)
            else:
                _waitpids.append(pid)
                ret = 0
        errobj = VhbackupError(REQUEST, self.T_('Initiate Restore'))
        if ret:
            errobj.pushlist(errlist)
        else:
            send_email_msg = [self.T_('You will be receiving the status and details of the job at the email address provided.')]
            errobj.errlist = send_email_msg
        REQUEST.RESPONSE.redirect('form_restore_ftp')



    def call_backend_import(self, urls, services, role, merge, recurse, key, email, mail_info):
        except_errors = ''
        try:
            in_info = {'merge': merge,
             'recurse': recurse,
             'key': key,
             'target': None,
             'restore_user_configs': 0,
             'restore_site_configs': 0,
             'restore_reseller_configs': 0}
            errs = virthost.vhimport(urls, services, role, in_info)
        except Exception, e:
            except_errors = ('Unknown Error: %s' % e)
            errs = []
        (status, content,) = vhbackuputils.display_error(errs)
        if except_errors:
            content.append(except_errors)
            status = 2
        logging.write_log(('\nRestore Status:%s' % status))
        logging.write_log(('\nRestore Errors:\n%s\n' % string.join(content, '\n')))
        if email:
            vhbackuputils.vhrestore_email_content(email, content, status, mail_info)
        os._exit(0)



    def call_backend_export(self, appliance, resellers, sites, users, outinfo, email, mail_info):
        except_errors = ''
        try:
            errs = virthost.vhexport(appliance, resellers, sites, users, outinfo)
        except Exception, e:
            except_errors = ('Unknown Error: %s' % e)
            errs = []
        (status, content,) = vhbackuputils.display_error(errs)
        if except_errors:
            content.append(except_errors)
            status = 2
        logging.write_log(('\nBackup Status:%s' % status))
        logging.write_log(('\nBackup Errors:\n%s\n' % string.join(content, '\n')))
        if ((mail_info['bk_type'] == 'Site') and ((status != 2) and (mail_info['loginlevel'] == 'siteadmin'))):
            mappings = virthost.get_mappings('domainmap')
            site = mappings[self._virtdomain()]
            sitefspath = virthost.domainfs_path(site)
            fpath = (sitefspath + '/var/local/lastbackup')
            f = file(fpath, 'w')
            f.close()
        if email:
            vhbackuputils.vhbackup_email_content(email, content, status, mail_info)
        os._exit(0)



    def manage_backup(self, REQUEST):
        """PUBLISHED"""
        formdata = REQUEST.form
        errlist = []
        split_threshold = None
        formdata['ftp_server'] = self.to_punycode(formdata['ftp_server'])
        formdata['email'] = self.puny_email(formdata['email'])
        if formdata['ftp_location']:
            errlist += self.check_ftp_location(formdata['ftp_location'])
        if (not errlist):
            if formdata.has_key('bk_type'):
                bk_type = self.get_backup_type(formdata['bk_type'])
            else:
                bk_type = self.get_backup_type('users')
            (appliance, resellers, sites, users,) = self.backup_parts(formdata)
            outinfo = {}
            if (formdata['ftp_location'] == ''):
                url = ('ftp://%s:%s@%s' % (formdata['ftp_username'],
                 formdata['ftp_password'],
                 formdata['ftp_server']))
            elif re.match('/', formdata['ftp_location']):
                url = ('ftp://%s:%s@%s/%s' % (formdata['ftp_username'],
                 formdata['ftp_password'],
                 formdata['ftp_server'],
                 formdata['ftp_location']))
            else:
                formdata['ftp_location'] = ('/%s' % formdata['ftp_location'])
                url = ('ftp://%s:%s@%s/%s' % (formdata['ftp_username'],
                 formdata['ftp_password'],
                 formdata['ftp_server'],
                 formdata['ftp_location']))
            backup_filename = '%(host)_%(name)_%(type)_%Y_%B_%d_%H_%M'
            url = ('%s/%s' % (url,
             backup_filename))
            outinfo['URL'] = url
            if (formdata.has_key('split_threshold') and (formdata['split_threshold'] != '')):
                split_threshold = long(self.get_split_threshold_value(formdata['split_unit'], formdata['split_threshold']))
                outinfo['split'] = split_threshold
            else:
                split_threshold = None
            outinfo['compressed'] = 'gz'
            email = formdata['email']
            mail_info = self.data_for_email(bk_type, 'backup')
            _garbage_collect_waitpids()
            pid = os.fork()
            if (pid == 0):
                self.call_backend_export(appliance, resellers, sites, users, outinfo, email, mail_info)
            else:
                _waitpids.append(pid)
                errobj = VhbackupError(REQUEST, self.T_('Initiate Backup'))
                errobj.pushlist(errlist)
                REQUEST.RESPONSE.redirect('index_html')
        else:
            errobj = VhbackupError(REQUEST, self.T_('Initiate Backup'))
            errobj.pushlist(errlist)
            REQUEST.RESPONSE.redirect('index_html')
        return 



    def manage_upload(self, REQUEST):
        """ PUBLISHED """
        session = self.getSession(REQUEST)
        formdata = {}
        formdata['email'] = REQUEST.form['email']
        if REQUEST.form.has_key('userlist'):
            formdata['userlist'] = REQUEST.form['userlist']
        if (REQUEST.form.has_key('bk_type_site') and (REQUEST.form['bk_type_site'] == 'true')):
            formdata['bk_type'] = 'sites'
        elif (REQUEST.form.has_key('bk_type_users') and (REQUEST.form['bk_type_users'] == 'true')):
            formdata['bk_type'] = 'users'
        session['form_data'] = formdata
        response = REQUEST.RESPONSE
        response.redirect('form_upload_backup')



    def upload_close(self, REQUEST):
        """ PUBLISHED """
        response = REQUEST.RESPONSE
        session = self.getSession(REQUEST)
        if session.has_key('backup_pid'):
            pid = int(session['backup_pid'])
            del session['backup_pid']
            try:
                os.kill(pid, 9)
            except:
                pass
        response.redirect('new_user_close_form')



    def upload_backup(self, REQUEST):
        """ PUBLISHED """
        errlist = []
        response = REQUEST.RESPONSE
        session = self.getSession(REQUEST)
        if session.has_key('form_data'):
            formdata = session['form_data']
        else:
            formdata = {}
        if formdata.has_key('bk_type'):
            bk_type = self.get_backup_type(formdata['bk_type'])
        else:
            formdata['bk_type'] = 'users'
            bk_type = self.get_backup_type('users')
        formdata['role_type'] = self.get_author()
        tmp_dict = self.scheduledata(formdata)
        formdata.update(tmp_dict)
        cmdstr = ''
        for (eachkey, eachval,) in formdata.items():
            if eachval:
                if re.search('list', str(type(eachval))):
                    field_stringval = self.get_stringform(eachval, eachkey)
                    cmdstr = ('%s --%s' % (cmdstr,
                     field_stringval))
                else:
                    cmdstr = ('%s --%s=%s' % (cmdstr,
                     eachkey,
                     eachval))

        mail_info = self.data_for_email(bk_type, 'backup')
        mailstring = ('%s:%s:%s' % (mail_info['loginlevel'],
         mail_info['bk_type'],
         mail_info['user']))
        cmd = ('ensim-python /usr/lib/opcenter/vhbackup/vhbackup_be_interface --type=vhbackup_cmdline %s --mail_info=%s' % (cmdstr,
         mailstring))
        try:
            _err = cStringIO.StringIO()
            remote_filename = self._backup_filename(REQUEST)
            response.setHeader('Content-Type', 'application/octet-stream')
            response.setHeader('Content-Disposition', ('attachment; filename=%s' % remote_filename))
            response.write('')
            ret = cmdlnpopen.cmd3_stream(cmd, None, session, self.backup_cmdCallBack, (response,
             _err))
            err = string.split(_err.getvalue(), '\n')
            _err.close()
        except Exception, e:
            logging.write_traceback_log('upload_backup')
            errlist.append(e)


    form_restore_result_tmpl = published.HTMLPage([_toolbar_html,
     _statusbar_html,
     published.HTMLFile('restore_result', globals())], selecteditem='Restore')

    def get_restore_progress_form(self, REQUEST):
        tmpl = self.form_restore_result_tmpl(self, REQUEST)
        idx = index(tmpl, 'PROGRESS')
        idx2 = (idx + len('PROGRESS'))
        part1 = tmpl[:idx]
        tmpl = tmpl[idx2:]
        idx = index(tmpl, 'ERRORS_AND_WARNINGS')
        idx2 = (idx + len('ERRORS_AND_WARNINGS'))
        part2 = tmpl[:idx]
        part3 = tmpl[idx2:]
        return (part1,
         part2,
         part3)



    def form_restore_result(self, REQUEST):
        """ PUBLISHED """
        (part1, part2, part3,) = self.get_restore_progress_form(REQUEST)
        response = REQUEST.response
        response.setHeader('Content-type', 'text/html')
        response.write('')
        response.write(part1)
        err = self.manage_restore_stream(REQUEST)
        response.write(part2)
        if (not err):
            err = [self.T_('No Error/Warnings')]
        else:
            err = [self.T_('Error/warnings occured')]
        for e in err:
            response.write(('<tr><td class=cell1>%s</td><tr>' % e))

        response.write(part3)



    def manage_restore_stream(self, REQUEST):
        remote_file = self.REQUEST.form['backup_file']
        flag = 0
        filenotfound = 'filenotfound'
        try:
            try:
                tmpfilename = self.download(remote_file)
                if (not os.path.getsize(tmpfilename)):
                    raise filenotfound
            except filenotfound:
                REQUEST.response.write(self.T_('Failed to download requested file. Requested file may not exist.'))
                REQUEST.response.write('<br>')
                REQUEST.response.write(self.T_('Restore not initiated.'))
                flag = 1
                return flag
            except:
                REQUEST.response.write(self.T_('Failed to download requested file'))
                REQUEST.response.write('<br>')
                REQUEST.response.write(self.T_('Restore not initiated.'))
                flag = 1
                return flag
            urls = ('%s' % tmpfilename)
            email = self.puny_email(REQUEST.form.get('email', ''))
            id = self._get_effective_user()
            role_type = self.get_author()
            if (role_type == 'siteadmin'):
                id = self._siteIndex()
                role = ('%s,%s' % (virthost.ROLE_SITEADMIN,
                 id))
            elif (role_type == 'useradmin'):
                domain = self._siteIndex()
                id = ('%s@%s' % (id,
                 domain))
                role = ('%s,%s' % (virthost.ROLE_SITEUSER,
                 id))
            mail_info = self.data_for_email(None, 'restore')
            mailstring = ('%s:None:%s' % (mail_info['loginlevel'],
             mail_info['user']))
            cmd = ("ensim-python /usr/lib/opcenter/vhbackup/vhbackup_be_interface --type=vhrestore --urls='%s' --services= --role=%s --merge=1 --recurse=  --email=%s --mail_info=%s" % (urls,
             role,
             email,
             mailstring))
            cmdpipe = cmdlnpopen.raw_cmd(cmd)
            flag = 0
            REQUEST.response.write(self.T_('Restore in progress...'))
            REQUEST.response.write('<br>\n')
            line = cmdpipe.fromchild.readline()
            while (len(line) > 0):
                flag = 1
                line = line.replace("\\n'", "'<br>")
                REQUEST.response.write(('%s<br>' % line))
                line = cmdpipe.fromchild.readline()


        finally:
            try:
                if os.access(tmpfilename, os.F_OK):
                    os.remove(tmpfilename)
            except:
                pass
            self.remove_from_session(tmpfilename)
            try:
                remote_file.close()
            except:
                pass

        if (flag == 0):
            REQUEST.response.write(self.T_('Restore completed.<br>\n'))
        else:
            REQUEST.response.write(self.T_('Error/Warnings occured during restore.<br>\n'))
        return flag



    def data_for_email(self, bk_type, type):
        mail_info = {}
        if (type == 'backup'):
            mail_info['bk_type'] = bk_type
        mail_info['loginlevel'] = self.get_author()
        user = self._get_effective_user()
        if (user == None):
            user = 'Appliance Administrator'
        mail_info['user'] = user
        return mail_info



    def download(self, remote_file):
        (tmpfilename, tmpfile,) = self._create_tempfile(remote_file.filename)
        try:
            data = remote_file.read(49152)
            while data:
                tmpfile.write(data)
                data = remote_file.read(49152)

            tmpfile.close()
            return tmpfilename
        except:
            tmpfile.close()
            os.remove(tmpfilename)
            raise 



    def _create_tempfile(self, remote_filename):
        tmpfilename = tempfile.mktemp()
        ext_pos = remote_filename.rfind('.')
        tmpfilename = (tmpfilename + remote_filename[ext_pos:])
        tmpfilefd = os.open(tmpfilename, ((os.O_CREAT | os.O_EXCL) | os.O_WRONLY), 448)
        try:
            tmpfile = os.fdopen(tmpfilefd, 'w', (16 * 1024))
            self.add_to_session(tmpfilename)
        except:
            os.close(tmpfilefd)
            raise 
        return (tmpfilename,
         tmpfile)



    def add_to_session(self, tmpfilename):
        session = self.getSession(self.REQUEST)
        if session:
            if (not session.has_key('tmp_file')):
                session['tmp_file'] = []
            session['tmp_file'].append(tmpfilename)



    def remove_from_session(self, tmpfilename):
        session = self.getSession(self.REQUEST)
        if session:
            if (session.has_key('tmp_file') and (tmpfilename in session['tmp_file'])):
                session['tmp_file'].remove(tmpfilename)


    new_user_close_form = published.HTMLPage([published.HTMLFile('base/common/window_close', globals())])
    properties_check = [{'check': 'string_IDN',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'ftpuser',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'length',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'length',
      'label': 'Passwords',
      'name': 'ftp_password'},
     {'check': 'email_IDN',
      'strict': 1,
      'label': 'Email',
      'name': 'email'},
     {'check': 'length',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'length',
      'label': 'Email',
      'name': 'email'},
     {'check': 'length',
      'label': 'The backup file name',
      'name': 'backup_file'}]
    form_restore_ftp = published.HTMLPage([_toolbar_html,
     _statusbar_html,
     published.HTMLFile('restore', globals(), properties=properties_check)], selecteditem='Restore')
    form_upload_backup = published.HTMLPage([published.HTMLFile('download', globals(), download_url='upload_backup', closewindow_url='upload_close')])

    def get_xml_encoding(self):
        raise 'to be implemented in the sub-classes'



    def get_xml_tag(self):
        return ('<?xml version="1.0" encoding="%s" ?>\n' % self.get_xml_encoding())


    properties_check = [{'check': 'string',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'ftpuser',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'length',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'password',
      'label': 'Passwords',
      'name': 'ftp_password'},
     {'check': 'length',
      'label': 'Passwords',
      'name': 'ftp_password'},
     {'check': 'email_IDN',
      'strict': 1,
      'label': 'Email',
      'name': 'email'},
     {'check': 'length',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'length',
      'label': 'Email',
      'name': 'email'},
     {'check': 'integer',
      'lencheck': 0,
      'label': 'Split Threshold',
      'name': 'split_threshold'}]
    form_bk_content = published.HTMLFile('backup_screen', globals(), properties=properties_check)
    form_bk_page = [_toolbar_html,
     _statusbar_html,
     form_bk_content]
    form_bk = published.HTMLPage(form_bk_page, selecteditem='Backup', title='Backup')
    properties_check1 = [{'check': 'string_IDN',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'ftpuser',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'length',
      'label': 'FTP Login',
      'name': 'ftp_username'},
     {'check': 'length',
      'label': 'Passwords',
      'name': 'ftp_password'},
     {'check': 'email_IDN',
      'strict': 1,
      'label': 'Email',
      'name': 'email'},
     {'check': 'length',
      'label': 'FTP server',
      'name': 'ftp_server'},
     {'check': 'length',
      'label': 'Email',
      'name': 'email'},
     {'check': 'integer',
      'lencheck': 0,
      'label': 'Split Threshold',
      'name': 'split_threshold'}]
    form_stream_bk_content = published.HTMLFile('backup_site_user', globals(), properties=properties_check1)
    form_stream_bk_page = [_toolbar_html,
     _statusbar_html,
     form_stream_bk_content]
    form_stream_bk = published.HTMLPage(form_stream_bk_page, selecteditem='Backup', title='Backup')
    form_appliance_scheduled_bk_content = published.HTMLFile('schedule_table', globals())
    form_appliance_scheduled_bk_page = [_toolbar_html,
     _statusbar_html,
     form_appliance_scheduled_bk_content]
    form_appliance_scheduled_bk = published.HTMLPage(form_appliance_scheduled_bk_page, selecteditem='Scheduled Backup', title='Scheduled Backup')
    form_new_scheduled_bk_content = published.HTMLFile('schedule_job', globals(), properties=properties_check, wpidn=wpidn)
    form_new_scheduled_bk_page = [_toolbar_html,
     _statusbar_html,
     form_new_scheduled_bk_content]
    form_new_scheduled_bk = published.HTMLPage(form_new_scheduled_bk_page, selecteditem='Scheduled Backup', title='Scheduled Backup')

    def render_option(self, REQUEST, type):
        selecteditems = []
        if REQUEST.form.has_key('filepath'):
            tmp_file = self.extract_file(REQUEST.form['filepath'])
        else:
            tmp_file = {}
        role_type = self.get_author()
        if (type == 'user'):
            list = self.userlist()
        if (role_type == 'reselleradmin'):
            list = self._get_resellersitelist(REQUEST)
        elif (type == 'site'):
            list = self._get_sitelist(REQUEST)
        elif (type == 'reseller'):
            list = self._get_resellerlist()
        option = ''
        if tmp_file.has_key('bk_type'):
            selectedlist = ''
            if ((tmp_file['bk_type'] == 'resellers') and ((role_type == 'appliance') and (type == 'reseller'))):
                selectedlist = tmp_file['resellerlist']
            if ((tmp_file['bk_type'] == 'sites') and ((role_type == 'appliance') and (type == 'site'))):
                selectedlist = tmp_file['sitelist']
            if ((tmp_file['bk_type'] == 'sites') and (role_type == 'reselleradmin')):
                selectedlist = tmp_file['sitelist']
            if ((tmp_file['bk_type'] == 'users') and ((role_type == 'siteadmin') and (type == 'user'))):
                selectedlist = tmp_file['userlist']
            selectedlist = string.replace(selectedlist, '""', '')
            selecteditems = string.split(selectedlist, ',')
            if ((tmp_file['bk_type'] == 'users') and ((role_type == 'siteadmin') and (type == 'user'))):
                items = []
                for each_item in selecteditems:
                    tmp_str = string.split(each_item, '@')
                    items.append(tmp_str[0])

                selecteditems = items
        flag = 0
        if (not selecteditems):
            option = ((option + '<option value="All" selected > ') + self.T_('All'))
        else:
            for each_item in selecteditems:
                if (str(each_item) == 'All'):
                    flag = 1
                    break

            if (flag == 1):
                option = ((option + '<option value="All" selected > ') + self.T_('All'))
            else:
                option = ((option + '<option value="All" > ') + self.T_('All'))
        for (key, value,) in list.items():
            flag = 0
            for each_item in selecteditems:
                if (str(each_item) == str(value)):
                    flag = 1
                    break

            if (flag == 1):
                if (((type == 'site') and (role_type == 'appliance')) or ((type == 'reseller') and (role_type == 'reselleradmin'))):
                    pvalue = wpidn.prettyutf8(wpidn.punycode_to_utf8(value))
                    option = (option + ('<option value="%s" selected > %s' % (value,
                     pvalue)))
                else:
                    option = (option + ('<option value="%s" selected > %s' % (value,
                     value)))
            elif (((type == 'site') and (role_type == 'appliance')) or ((type == 'reseller') and (role_type == 'reselleradmin'))):
                pvalue = wpidn.prettyutf8(wpidn.punycode_to_utf8(value))
                option = (option + ('<option value="%s" > %s' % (value,
                 pvalue)))
            else:
                option = (option + ('<option value="%s" > %s' % (value,
                 value)))

        return option



    def get_backup_type(self, bk_type):
        if (bk_type == 'appliance'):
            type = 'Appliance'
        elif (bk_type == 'resellers'):
            type = 'Reseller'
        elif (bk_type == 'sites'):
            type = 'Site'
        elif (bk_type == 'users'):
            type = 'Users'
        else:
            type = None
        return type



    def seevalue(self, formdata):
        properties = ['frequency',
         'ftp_server',
         'ftp_username',
         'ftp_location',
         'minute',
         'hour',
         'week_day',
         'month_day',
         'email',
         'username',
         'ftp_password',
         'bk_type']
        tmp_file = {}
        if formdata.has_key('filepath'):
            tmp_file = self.extract_file(formdata['filepath'])
        for k in properties:
            if tmp_file.has_key(k):
                formdata[k] = tmp_file[k]
            else:
                formdata[k] = ''




    def extract_file(self, filepath):
        file_parts = string.split(filepath, '/')
        file_key = file_parts[(len(file_parts) - 1)]
        dir_key = string.join(file_parts[:(len(file_parts) - 2)], '/')
        if self._backup_schedules[dir_key].has_key(file_key):
            tmp_file = self._backup_schedules[dir_key][file_key]
        else:
            tmp_file = {}
        return tmp_file



    def get_schedules(self, REQUEST):
        try:
            user = self._get_effective_user()
            if (user == None):
                user = 'root'
            output = self.get_schedules_for_user(user)
            return output
        except:
            self.status().failed(self.T_('Failed to list backup list'))



    def render_schedule_item(self, item):
        freq_dict = {'daily': self.T_('Daily'),
         'weekly': self.T_('Weekly'),
         'monthly': self.T_('Monthly')}
        filename = item['filename']
        editAction = ('<a href=form_new_scheduled_bk?filepath=%s><img src=edit_gif alt=%s onMouseOver="status=(\'%s\'); return true;" onMouseOut="status=\'\'; return true;" onClick="status=\'Edit Schedule\'; return true;" width=20 height=20 border=0></a>' % (item['filepath'],
         self.T_('Edit'),
         self.T_('Edit Schedule')))
        removeAction = ('<a href=manage_remove_schedule?filepath=%s onClick="return confirm(\'%s\')"><img src=remove_gif alt=%s onMouseOver="status=(\'%s\'); return true;" onMouseOut="status=\'\' ; return true;" width=20 height=20 border=0></a>' % (item['filepath'],
         self.T_('Are you sure you want to remove this entry?'),
         self.T_('Remove'),
         self.T_('Remove Schedule')))
        out = ''
        if item.has_key('bk_type'):
            type = self.get_backup_type(item['bk_type'])
        else:
            type = self.get_backup_type('users')
        out = (out + ('<td class=cell1>%s</td>' % self.T_(type)))
        out = (out + ('<td class=cell1>%s</td>' % freq_dict[item['frequency']]))
        type = ''
        if item.has_key('data_age'):
            type = (type + ('Data older than <b>%s</b> day(s) ' % item['data_age']))
        if item.has_key('ftp_server'):
            item['ftp_username'] = item['ftp_username'].strip("'")
            item['ftp_server'] = item['ftp_server'].strip("'")
            item['email'] = item['email'].strip("'")
            type = (' Ftp: <b>%s@%s</b> ' % (item['ftp_username'],
             wpidn.prettypuny(item['ftp_server'])))
        out = (out + ('<td class=cell1>%s</td>' % type))
        if item.has_key('email'):
            out = (out + ('<td class=cell1>%s</td>' % wpidn.prettypuny_email(item['email'])))
        else:
            out = (out + '<td class=cell1> no email</td>')
        out = (out + ('<td width=10%% class=cell1>%s&nbsp;%s</td>' % (editAction,
         removeAction)))
        return out



    def _get_schedule_filedata(self, formdata):
        properties = ['frequency',
         'ftp_server',
         'ftp_username',
         'ftp_password',
         'ftp_location',
         'minute',
         'hour',
         'week_day',
         'month_day',
         'email',
         'username',
         'bk_type',
         'role_type',
         'schedulefile']
        properties_optional = ['resellerlist',
         'sitelist',
         'userlist',
         'reseller_name',
         'domain',
         'user']
        tmp_dict = self.scheduledata(formdata)
        formdata.update(tmp_dict)
        filedata = ''
        filedata = ('%s#!/bin/sh\n' % filedata)
        for field in properties:
            if (formdata.has_key(field) and (formdata[field] != None)):
                if (("'" in formdata[field]) or ("\\" in formdata[field])) :
                    raise('Illegal chars in posted parameter') ;
                else:
                    filedata = ("%s\n%s='%s'" % (filedata,
                     field,
                     formdata[field].replace("'", "\\'")))

        for field in properties_optional:
            if (formdata.has_key(field) and (formdata[field] != None)):
                if re.search('list', str(type(formdata[field]))):
                    field_stringval = self.get_stringform(formdata[field], field)
                    filedata = ('%s\n%s' % (filedata,
                     field_stringval))
                else:
                    if (formdata.has_key(field) and (formdata[field] != None)):
                        if (("'" in formdata[field]) or ("\\" in formdata[field])) :
                            raise('Illegal chars in posted parameter') ;
                    else:
                        filedata = ('%s\n%s=%s' % (filedata,
                         field,
                         formdata[field]))
            else:
                filedata = ('%s\n%s=' % (filedata,
                 field))

        week_day_name = ''
        if (formdata.has_key('frequency') and (formdata['frequency'] == 'weekly')):
            weekdays = self.weekdays()
            for eachday in weekdays:
                if (int(eachday[1]) == int(formdata['week_day'])):
                    week_day_name = eachday[0]
                    break

        filedata = ('%s\nweek_day_name=%s' % (filedata,
         week_day_name))
        if (formdata.has_key('split_threshold') and (formdata['split_threshold'] != '')):
            split_threshold = long(self.get_split_threshold_value(formdata['split_unit'], formdata['split_threshold']))
        else:
            split_threshold = ''
        split_threshold_str = ("split_threshold='%s'" % split_threshold)
        backup_filename = '%(host)_%(name)_%(type)_%Y_%B_%d_%H_%M'
        url = ('url="%s"' % backup_filename)
        filedata = ('\n%s\n%s\n%s' % (filedata,
         url,
         split_threshold_str))
        filedata = ('\n%s\nensim-python /usr/lib/opcenter/vhbackup/vhbackup_be_interface --type=vhbackup_cmdline --url=$url --time=$frequency:$month_day:$week_day_name:$hour:$minute --email=$email --split_threshold=$split_threshold --mail_info=$role_type:$bk_type:$username --resellerlist=$resellerlist --sitelist=$sitelist --userlist=$userlist --reseller_name=$reseller_name --domain=$domain --user=$user --role_type=$role_type --bk_type=$bk_type --selfFile=$schedulefile' % filedata)
        return filedata



    def get_stringform(self, data, type):
        stringform = ''
        if data:
            for each in data:
                stringform = ('%s,%s' % (stringform,
                 each))

            tmpstr = string.split(stringform, ',', 1)
            tmpstr = ('%s=%s' % (type,
             tmpstr[1]))
        else:
            tmpstr = ('%s=""' % type)
        return tmpstr



    def _add_schedule_entry(self, formdata):
        entry_tobe_deleted = ''
        vhbackup_dir = '/var/VhbackupSchedules'
        daily_container = ('%s/schedule_daily' % vhbackup_dir)
        weekly_container = ('%s/schedule_weekly' % vhbackup_dir)
        monthly_container = ('%s/schedule_monthly' % vhbackup_dir)
        frequency = formdata['frequency']
        if (not os.path.isdir(vhbackup_dir)):
            os.mkdir(vhbackup_dir)
        if (not os.path.isdir(daily_container)):
            os.mkdir(daily_container)
        if (not os.path.isdir(weekly_container)):
            os.mkdir(weekly_container)
        if (not os.path.isdir(monthly_container)):
            os.mkdir(monthly_container)
        if (frequency == 'daily'):
            store_dir_name = ('%s/%s:%s' % (daily_container,
             formdata['minute'],
             formdata['hour']))
            store_dir_name_val = ('%s/%s\\:%s' % (daily_container,
             formdata['minute'],
             formdata['hour']))
        elif (frequency == 'weekly'):
            store_dir_name = ('%s/%s:%s:%s' % (weekly_container,
             formdata['minute'],
             formdata['hour'],
             formdata['week_day']))
            store_dir_name_val = ('%s/%s\\:%s\\:%s' % (weekly_container,
             formdata['minute'],
             formdata['hour'],
             formdata['week_day']))
        elif (frequency == 'monthly'):
            store_dir_name = ('%s/%s:%s:%s' % (monthly_container,
             formdata['minute'],
             formdata['hour'],
             formdata['month_day']))
            store_dir_name_val = ('%s/%s\\:%s\\:%s' % (monthly_container,
             formdata['minute'],
             formdata['hour'],
             formdata['month_day']))
        else:
            print 'error'
        filename = self.get_filename()
        formdata['schedulefile'] = ('%s/%s' % (store_dir_name,
         filename))
        filedata = self._get_schedule_filedata(formdata)
        if formdata.has_key('filepath'):
            if os.path.isfile(formdata['filepath']):
                dir_tobe_deleted = posixpath.dirname(formdata['filepath'])
                files = os.listdir(dir_tobe_deleted)
                if ((len(files) == 1) and (dir_tobe_deleted != store_dir_name)):
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3(('/usr/lib/opcenter/base/services/vhbackup/extract_cron_string_data "%s" > /usr/lib/opcenter/base/services/vhbackup/cron_string_data' % formdata['filepath']))
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3('/usr/lib/opcenter/base/services/vhbackup/create_cron_string')
                    entry_tobe_deleted = outcmd[0]
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3(('/usr/lib/opcenter/base/services/vhbackup/create_cron_string %s/schedule_backup %s' % (vhbackup_dir,
                     entry_tobe_deleted)))
                    os.remove(formdata['filepath'])
                    os.rmdir(dir_tobe_deleted)
                else:
                    os.remove(formdata['filepath'])
        if os.path.isdir(store_dir_name):
            fd = open(('%s/%s' % (store_dir_name,
             filename)), 'a')
            fd.write(('%s' % filedata))
            fd.close()
            p = os.system(('chmod 760 %s/%s' % (store_dir_name,
             filename)))
        else:
            os.mkdir(store_dir_name)
            fd = open(('%s/%s' % (store_dir_name,
             filename)), 'w')
            fd.write(('%s' % filedata))
            fd.close()
            p = os.system(('chmod 760 %s/%s' % (store_dir_name,
             filename)))
            if (formdata['frequency'] == 'daily'):
                cron_string = ('%s %s * * * run-parts %s' % (formdata['minute'],
                 formdata['hour'],
                 store_dir_name_val))
            if (formdata['frequency'] == 'weekly'):
                cron_string = ('%s %s * * %s run-parts %s' % (formdata['minute'],
                 formdata['hour'],
                 formdata['week_day'],
                 store_dir_name_val))
            if (formdata['frequency'] == 'monthly'):
                cron_string = ('%s %s %s * * run-parts %s' % (formdata['minute'],
                 formdata['hour'],
                 formdata['month_day'],
                 store_dir_name_val))
            fd = open(('%s/schedule_backup' % vhbackup_dir), 'a')
            fd.write(('%s\n' % cron_string))
            fd.close()
            vhbackuputils.append_crontab(('%s/schedule_backup' % vhbackup_dir), vhbackup_dir)



    def get_filename(self):
        date = localtime()
        filename = ('ocwbackup%d%d%d_%d%d%d' % (date[0],
         date[1],
         date[2],
         date[3],
         date[4],
         date[5]))
        return filename



    def manage_remove_schedule(self, REQUEST):
        """remove a schedule"""
        vhbackup_dir = '/var/VhbackupSchedules'
        if REQUEST.form.has_key('filepath'):
            if os.path.isfile(REQUEST.form['filepath']):
                dir_tobe_deleted = posixpath.dirname(REQUEST.form['filepath'])
                files = os.listdir(dir_tobe_deleted)
                if (len(files) == 1):
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3(('/usr/lib/opcenter/base/services/vhbackup/extract_cron_string_data "%s" > /usr/lib/opcenter/base/services/vhbackup/cron_string_data' % REQUEST.form['filepath']))
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3('/usr/lib/opcenter/base/services/vhbackup/create_cron_string')
                    entry_tobe_deleted = outcmd[0]
                    (outcmd, errcmd, noerr,) = cmdlnpopen.cmd3(('/usr/lib/opcenter/base/services/vhbackup/create_cron_string %s/schedule_backup %s' % (vhbackup_dir,
                     entry_tobe_deleted)))
                    os.remove(REQUEST.form['filepath'])
                    os.rmdir(dir_tobe_deleted)
                    vhbackuputils.append_crontab(('%s/schedule_backup' % vhbackup_dir), vhbackup_dir)
                else:
                    os.remove(REQUEST.form['filepath'])
        REQUEST.RESPONSE.redirect('form_appliance_scheduled_bk')



    def manage_schedule(self, REQUEST):
        """add a schedule"""
        u = self.getSession(REQUEST)
        username = self._get_effective_user()
        if (username == None):
            username = 'root'
        role_type = self.get_author()
        formdata = REQUEST.form
        formdata['ftp_server'] = self.to_punycode(formdata['ftp_server'])
        formdata['email'] = self.puny_email(formdata['email'])
        (retval, errstring,) = self.check_all_lists(formdata)
        if (('ftp_server' in formdata) and ("'" in formdata['ftp_server'])):
            errstring = ('%s %s' % (self.T_('FTP Server'),
             self.T_('contains invalid characters')))
            retval = 1
        if (('ftp_username' in formdata) and ("'" in formdata['ftp_username'])):
            errstring = ('%s %s' % (self.T_('FTP Login'),
             self.T_('contains invalid characters')))
            retval = 1
        if (('ftp_password' in formdata) and ("'" in formdata['ftp_password'])):
            errstring = self.T_('Invalid Password value or Password values do not match.')
            retval = 1
        if (('ftp_location' in formdata) and ("'" in formdata['ftp_location'])):
            errstring = ('%s %s' % (self.T_('FTP Location'),
             self.T_('contains invalid characters')))
            retval = 1
        if (('split_threshold' in formdata) and ("'" in formdata['split_threshold'])):
            errstring = ('%s %s' % (self.T_('Threshold'),
             self.T_('contains invalid characters')))
            retval = 1
        if (('email' in formdata) and ("'" in formdata['email'])):
            errstring = ('%s %s' % (self.T_('Email'),
             self.T_('contains invalid characters')))
            retval = 1
        if retval:
            session = self.getSession(REQUEST)
            session['lastActionStatus']['flag'] = 1
            session['lastActionStatus']['status'] = 0
            session['lastActionStatus']['msg'] = self.T_(('%s' % errstring))
            session['lastActionStatus']['msglist'] = [errstring]
            if formdata.has_key('filepath'):
                REQUEST.RESPONSE.redirect(('form_new_scheduled_bk?filepath=%s' % formdata['filepath']))
            else:
                REQUEST.RESPONSE.redirect('form_new_scheduled_bk')
        else:
            formdata['username'] = username
            formdata['role_type'] = role_type
            self._add_schedule_entry(formdata)
            REQUEST.RESPONSE.redirect('form_appliance_scheduled_bk')



    def getdata_from_file(self, file):
        fd = open(('%s' % file), 'r')
        file_lines = fd.readlines()
        fd.close()
        file_data = {}
        for line in file_lines:
            line = string.replace(line, '\n', '')
            tmp_val = string.split(line, '=', 1)
            if (len(tmp_val) == 2):
                file_data[string.strip(tmp_val[0])] = string.strip(tmp_val[1])

        file_data['filepath'] = file
        return file_data



    def get_all_schedules(self):
        vhbackup_dir = '/var/VhbackupSchedules'
        daily_container = ('%s/schedule_daily' % vhbackup_dir)
        weekly_container = ('%s/schedule_weekly' % vhbackup_dir)
        monthly_container = ('%s/schedule_monthly' % vhbackup_dir)
        if (not os.path.isdir(vhbackup_dir)):
            os.mkdir(vhbackup_dir)
        if (not os.path.isdir(daily_container)):
            os.mkdir(daily_container)
        if (not os.path.isdir(weekly_container)):
            os.mkdir(weekly_container)
        if (not os.path.isdir(monthly_container)):
            os.mkdir(monthly_container)
        schedule_dirs = [daily_container,
         weekly_container,
         monthly_container]
        schedules = {}
        schedule_dirs = [daily_container,
         weekly_container,
         monthly_container]
        for schdir in schedule_dirs:
            schedules[schdir] = {}
            time_dir = os.listdir(schdir)
            if (len(time_dir) != 0):
                for each_time_dir in time_dir:
                    each_time_dirpath = ('%s/%s' % (schdir,
                     each_time_dir))
                    sch_files = os.listdir(each_time_dirpath)
                    if (len(sch_files) != 0):
                        for each_sch_file in sch_files:
                            file_path = ('%s/%s' % (each_time_dirpath,
                             each_sch_file))
                            data = self.getdata_from_file(file_path)
                            schedules[schdir][each_sch_file] = data



        return schedules



    def get_schedules_for_user(self, user):
        self._backup_schedules = self.get_all_schedules()
        reqd_schedules = []
        for (schkey, schvalue,) in self._backup_schedules.items():
            for (schfilekey, schfilevalue,) in schvalue.items():
                if (('_virtdomain' not in dir(self)) or (schfilevalue['domain'] == self._virtdomain())):
                    if (schfilevalue['username'] == user):
                        schfilevalue['filename'] = schfilekey
                        reqd_schedules.append(schfilevalue)


        return reqd_schedules



    def beautify_restore_filename(self, filenam):
        """ usage: beautify_restore_filename (filenam) -> pretty-html """
        return string.join(map(lambda x:repr(self.idn(x))
, wpidn.idntokens(filenam, ['@',
         '.',
         '_'])), '')




# local variables:
# tab-width: 4