Viewing file:  rhnregGui.py (34.86 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#!/usr/bin/python
# this is a module containing classes for the registration related windows in
# gui.py. The code is split up so we can reuse it in the firstboot modules
import sys
sys.path.insert(0, "/usr/share/rhn/up2date_client/")
sys.path.insert(1, "/usr/share/rhn")
import string
import socket
import gtk
import gnome, gnome.ui
# XXX: why is this import necessary? We use only gtk.glade in the code...
from gtk import glade
import gobject
from rhpl.translate import _, N_
from rhpl import translate
translate.textdomain("up2date")
gtk.glade.bindtextdomain ("up2date")
from rhn import rpclib
import rhnreg
import up2dateErrors
import hardware
import messageWindow
import progress
import rpmUtils
import up2dateAuth
import rhnChannel
import up2dateUtils
import config
import configdlg
import up2dateLog
import sourcesConfig
gladefile = "/usr/share/rhn/up2date_client/rh_register.glade"
# this we need to carry between screen, so stash at module scope
global username, password, email, useExisting, newAccount, productInfo
username = None
password = None
email = None
useExisting = None
newAccount = None
productInfo = None
#caps = rhnreg.getCaps()
# detect if were talking to RHN or not, needed so that
# the modules can tell firstboot not to run in that case.
def useRHN():
useRhn = 0
sources = sourcesConfig.getSources()
for source in sources:
if source['type'] == "up2date":
useRhn = 1
return useRhn
class LoginPage:
def __init__(self):
self.loginXml = gtk.glade.XML(gladefile,
"initialLoginWindowVbox", domain="up2date")
self.loginXml.signal_autoconnect (
{ "onNewAccountButtonToggled": self.loginPageOnCreateNewAccountButtonToggled,
"onUseExistingAccountButtonToggled": self.loginPageOnCreateNewAccountButtonToggled,
"onOptOutButtonToggled" : self.loginPageOnCreateNewAccountButtonToggled,
"onPrivacyButtonClicked" : self.showPrivacyDialog,
"onNetworkConfigButtonClicked" : self.showNetworkConfigDialog,
})
def loginPagePrepareVbox(self):
loginWindowVbox = self.loginXml.get_widget("initialLoginWindowVbox")
vbox = self.xml.get_widget("loginPageVbox")
return vbox
def getCaps(self):
caps = rhnreg.getCaps()
# onLoginPagePrepare will need to call this
def loginPagePrepare(self):
loginWindowVbox = self.loginXml.get_widget("initialLoginWindowVbox")
# so we reset to this when coming from the optOut confirm window
self.loginXml.get_widget("useExistingAccountButton").set_active(gtk.TRUE)
self.optOut = 0
self.newAccount = 0
self.useExisting = 1
return loginWindowVbox
def loginPageVerify(self):
self.loginPw = self.loginXml.get_widget("loginPasswordEntry")
self.loginUname = self.loginXml.get_widget("loginUserEntry")
global username, password
username = self.loginUname.get_text()
password = self.loginPw.get_text()
useExistingButton = self.loginXml.get_widget("useExistingAccountButton")
newAccountButton = self.loginXml.get_widget("newAccountButton")
optOutButton = self.loginXml.get_widget("optOutButton")
global useExisting, newAccount
useExisting = useExistingButton.get_active()
newAccount = newAccountButton.get_active()
self.optOut = optOutButton.get_active()
# FIXME: needs
if self.newAccount:
self.loginPageOnNewAccount()
return False
if self.optOut:
self.optOut = 1
self.loginPageOnOptOut()
return False
# validate / check user name
if self.loginUname.get_text() == "":
# we assume someone else creates this method...
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter a user name."))
self.loginUname.grab_focus()
return True
if self.loginPw.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter and verify a password."))
self.loginPw.grab_focus()
return True
def loginPageApply(self):
# get the caps info before we show the activastion page which needs the
# caps. _but_ we need to do this after we configure the network...
self.getCaps()
self.alreadyRegistered = 1
try:
self.alreadyRegistered = rhnreg.reserveUser(self.loginUname.get_text(),
self.loginPw.get_text())
except up2dateErrors.ValidationError, e:
self.setArrowCursor()
print e.errmsg
dlg = messageWindow.ErrorDialog(messageWindow.wrap_text(_("The server indicated an error:\n") + e.errmsg))
self.loginUname.grab_focus()
return gtk.TRUE
except up2dateErrors.CommunicationError, e:
self.setArrowCursor()
print e.errmsg
self.fatalError(_("There was an error communicating with the registration server. The message was:\n") + e.errmsg)
if self.alreadyRegistered == 0:
# this account doesnt exist
self.setArrowCursor()
errmesg = _("That user account and password is not valid\n")
dlg = messageWindow.ErrorDialog(messageWindow.wrap_text(errmesg))
newAccountButton = self.loginXml.get_widget("newAccountButton")
newAccountButton.set_active(gtk.TRUE)
return gtk.TRUE
return gtk.FALSE
# FIXME: this should be shared with the stuff up2date/gui.py uses
# maybe in up2date/gui_shared.py ?
def loginPageOnCreateNewAccountButtonToggled(self, button):
useExistingButton = self.loginXml.get_widget("useExistingAccountButton")
newAccountButton = self.loginXml.get_widget("newAccountButton")
optOutButton = self.loginXml.get_widget("optOutButton")
self.useExisting = useExistingButton.get_active()
self.newAccount = newAccountButton.get_active()
self.optOut = optOutButton.get_active()
if self.useExisting:
self.loginXml.get_widget("loginUserEntry").set_sensitive(gtk.TRUE)
self.loginXml.get_widget("loginPasswordEntry").set_sensitive(gtk.TRUE)
self.loginXml.get_widget("loginPasswordEntryLabel").set_sensitive(gtk.TRUE)
self.loginXml.get_widget("loginUserEntryLabel").set_sensitive(gtk.TRUE)
if self.newAccount:
self.loginXml.get_widget("loginUserEntry").set_sensitive(gtk.FALSE)
self.loginXml.get_widget("loginPasswordEntry").set_sensitive(gtk.FALSE)
self.loginXml.get_widget("loginPasswordEntryLabel").set_sensitive(gtk.FALSE)
self.loginXml.get_widget("loginUserEntryLabel").set_sensitive(gtk.FALSE)
def showPrivacyDialog(self, button):
priv = PrivacyDialog()
def showNetworkConfigDialog(self, button):
cfg = configdlg.Gui(firstboot=1)
class OptOutPage:
def __init__(self):
self.optOutXml = gtk.glade.XML(gladefile,
"optOutWindowVbox", domain="up2date")
self.optOutXml.signal_autoconnect(
{ "onOptInButtonToggled" : self.optOutPageOnOptInButtonToggled})
def optOutPagePrepareVbox(self):
loginWindowVbox = self.loginXml.get_widget("optOutWindowVbox")
vbox = self.xml.get_widget("optOutPageVbox")
return vbox
def optOutPageOnOptInButtonToggled(self, button):
optInButton = self.optOutXml.get_widget("OptInButton")
optOutButton = self.optOutXml.get_widget("OptOutButton")
self.optInReally = optInButton.get_active()
self.optOutReally = optOutButton.get_active()
def optOutPagePrepare(self):
optOutWindowVbox = self.optOutXml.get_widget("optOutWindowVbox")
self.optInReally = 1
self.optOutReally = 0
return optOutWindowVbox
def optOutPageVerify(self):
pass
def optOutPageApply(self):
if self.optInReally:
self.optOutPageOptIn()
if self.optOutReally:
self.optOutPageOptOut()
return gtk.TRUE
class ActivatePage:
useExisting = None
newAccount = None
def __init__(self):
self.activateXml = gtk.glade.XML(gladefile,
"activateWindowVbox", domain="up2date")
self.activateXml.signal_autoconnect (
{ "onActivateExistingSubscriptionButtonToggled" : self.activatePageOnActivateExistingSubscriptionButtonToggled,
"onHardwareDetailButtonClicked" : self.showHardwareDialog,
"onPackageDetailButtonClicked" : self.showPackageDialog,
})
self.initProfile = None
# we have to do some fb specific magic, so this
# tells us if were running in firstboot or not
self.fb = None
self.cfg = config.initUp2dateConfig()
self.activationNoPackages = None
self.regNum = None
self.noChannels = None
self.serviceNotEnabled = None
def getRemaining(self):
global username, password, newAccount
# if its a new user (aka, username is reserved but not registered)
# this call will fail, so skip it on the case of new user. Since
# its a new user, were going to assume they have no entitlements
if newAccount:
subs = 0
return subs
# if the server doesnt support this call, assume they
# can use an entitlement (-1 == unlimited subs)
if self.cfg['supportsRemainingSubscriptions']:
try:
subs = rhnreg.getRemainingSubscriptions(username, password,
up2dateUtils.getArch(),
up2dateUtils.getVersion())
except rpclib.Fault, f:
if abs(f.faultCode) == 2:
error = f.faultString
dlg = messageWindow.ErrorDialog("%s" % error)
return True
elif abs(f.faultCode) == 3:
error = f.faultString
dlg = messageWindow.ErrorDialog("%s" % error)
return True
elif abs(f.faultCode) == 19:
# uh, yeah, this is a work around for now. The
# server needs to be more fine grained on why it
# throws this error
return 0
# error = f.faultString
# dlg = messageWindow.ErrorDialog("%s" % error)
# return True
raise
else:
subs = -1
return subs
# we cant do this on module load because there might be a valid interface
# but zero connectivity
def getHardware(self):
try:
self.hardware = hardware.Hardware()
except:
print _("Error running hardware profile")
def updateSubscriptions(self):
self.subs = self.getRemaining()
if int(self.subs) != 0:
button = self.activateXml.get_widget("activateExistingSubscriptionButton")
#print "button: %s" % dir(button)
button.set_label(_("""Use one of my existing, active subscriptions."""))
def populateProfile(self):
if not self.initProfile:
profileName = None
hostname = None
if self.hardware:
for hw in self.hardware:
if hw['class'] == 'NETINFO':
hostname = hw.get('hostname')
ipaddr = hw.get('ipaddr')
# the check against "unknown" is a bit lame, but it's
# the minimal change to fix #144704
if hostname and (hostname != "unknown"):
profileName = hostname
else:
if ipaddr:
profileName = ipaddr
if profileName:
self.activateXml.get_widget("systemNameEntry").set_text(profileName)
else:
profileName = "unknown"
self.initProfile = gtk.TRUE
self.setArrowCursor()
# we refresh the page as were going though the dialog, after the inital
# creation from "setupScreen". The reason we have to do this is that
# username/password isnt known the first time activatePagePrepare is ran
def activatePagePrepare(self):
activateVbox = self.activateXml.get_widget("activateWindowVbox")
# this is a kluge... firstboot initializes all the screens at once,
# while register inits them as they are shown. So in this case, for
# firstboot, we dont run updateSubscriptions at init (since the info
# it needs doesnt exist yet. But for rhn_register, we run it at init
# we use the fact that firstboot screens have to have "moduleName" defined
# and that rhn_register doesnt...
if not hasattr(self, "moduleName"):
self.updateSubscriptions()
# part of fix for #144704
self.getHardware()
self.populateProfile()
return activateVbox
def activatePageOnActivateExistingSubscriptionButtonToggled(self, button):
activateExistingSubscriptionButton = self.activateXml.get_widget("activateExistingSubscriptionButton")
useRegistrationNumberButton = self.activateXml.get_widget("useRegistrationNumberButton")
self.activateExistingSubscription = activateExistingSubscriptionButton.get_active()
self.useRegistrationNumber = useRegistrationNumberButton.get_active()
if self.activateExistingSubscription:
self.activateXml.get_widget("registrationNumberLabel").set_sensitive(gtk.FALSE)
self.activateXml.get_widget("registrationNumberEntry").set_sensitive(gtk.FALSE)
self.activateXml.get_widget("registrationNumberEntry").set_text("")
self.regNum = None
if self.useRegistrationNumber:
self.activateXml.get_widget("registrationNumberLabel").set_sensitive(gtk.TRUE)
self.activateXml.get_widget("registrationNumberEntry").set_sensitive(gtk.TRUE)
def activatePageVerify(self):
self.useRegistrationNumber = None
systemNameEntry = self.activateXml.get_widget("systemNameEntry")
self.regNumEntry = self.activateXml.get_widget("registrationNumberEntry")
activateExistingSubscriptionButton = self.activateXml.get_widget("activateExistingSubscriptionButton")
useRegistrationNumberButton = self.activateXml.get_widget("useRegistrationNumberButton")
sendHardwareButton = self.activateXml.get_widget("sendHardwareButton")
sendPackageListButton = self.activateXml.get_widget("sendPackageListButton")
self.sendHardware = sendHardwareButton.get_active()
self.sendPackages = sendPackageListButton.get_active()
self.activateExisting = activateExistingSubscriptionButton.get_active()
self.newActivation = useRegistrationNumberButton.get_active()
if systemNameEntry.get_text() == "":
dlg = messageWindow.ErrorDialog(_("You must choose a name for this profile."))
systemNameEntry.grab_focus()
return True
if self.activateExisting:
# FIXME: spec doesnt mention much about what to do if they dont
# have compatible entitlements
pass
if self.newActivation:
if self.regNumEntry.get_text() == "":
dlg = messageWindow.ErrorDialog(_("You must enter a registration number."))
self.regNumEntry.grab_focus()
return True
self.regNum = self.regNumEntry.get_text()
if not self.sendPackages:
self.activationNoPackages = 1
return False
def __updateContactInfo(self, newAccount, productInfo, uname, password, pwin):
try:
if newAccount:
rhnreg.updateContactInfo(uname, password, productInfo)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem registering personal information:\n") + e.errmsg)
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem registering personal information"))
return True
return False
def __registerProduct(self, newAccount, productInfo, pwin):
try:
if newAccount:
rhnreg.registerProduct(self.systemId, productInfo, self.oemInfo)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem registering personal information:\n") + e.errmsg)
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem registering personal information"))
return True
return False
def activatePageApply(self):
self.setBusyCursor()
pwin = progress.Progress()
pwin.setLabel(_("Sending your profile information to Red Hat Network. Please wait."))
self.systemId = None
global newAccount, useExisting, email, username, password
other = None
if self.fb:
uname = username
passwd = password
if useExisting:
emailaddress = ""
else:
emailaddress = email
else:
if self.useExisting:
uname = self.loginXml.get_widget("loginUserEntry").get_text()
passwd = self.loginXml.get_widget("loginPasswordEntry").get_text()
emailaddress = ""
if self.newAccount:
uname = self.newAccountXml.get_widget("newAccountUserEntry").get_text()
passwd = self.newAccountXml.get_widget("newAccountPasswordEntry").get_text()
emailaddress = self.newAccountXml.get_widget("newAccountEmailEntry").get_text()
if self.regNum:
other = {'registrationNumber' : self.regNum}
profileName = self.activateXml.get_widget("systemNameEntry").get_text()
# fixme: make these a class singleton?
# legacy cruft
try:
if useExisting:
rhnreg.registerUser(uname, passwd)
else:
rhnreg.registerUser(uname, passwd, emailaddress)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem registering user name:\n") + e.errmsg)
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem registering username."))
return True
pwin.setProgress(1, 6)
try:
self.systemId = rhnreg.registerSystem(uname, passwd, profileName, other=other)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem registering system:\n") + e.errmsg)
except up2dateErrors.RhnUuidUniquenessError, e:
pwin.hide()
self.fatalError(_("Problem registering system:\n") + e.errmsg)
except up2dateErrors.InvalidProductRegistrationError, e:
pwin.hide()
dlg = messageWindow.ErrorDialog(_("The subscription number [ %s ] provided is not a valid subscription number." %
other['registrationNumber']))
self.regNumEntry.grab_focus()
return True
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem registering system."))
return True
pwin.setProgress(2,6)
# write the system id out.
if self.systemId:
if not rhnreg.writeSystemId(self.systemId):
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem writing out system id to disk."))
return True
else:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("There was a problem registering this system."))
return True
# incorporate the info from the oemInfoFile as well
self.oemInfo = rhnreg.getOemInfo()
global productInfo
if self.cfg['supportsUpdateContactInfo']:
ret = self.__updateContactInfo(newAccount, productInfo, uname, password, pwin)
else:
ret = self.__registerProduct(newAccount, productInfo, pwin)
if ret:
return ret
pwin.setProgress(3, 6)
# maybe upload hardware profile
if self.sendHardware:
try:
rhnreg.sendHardware(self.systemId, self.hardware)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem sending hardware profile:\n") + e.errmsg)
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem sending hardware profile."))
return True
pwin.setProgress(4, 6)
if self.sendPackages:
# interesting...
getInfo = 0
# if self.cfg['supportsExtendedPackageProfile']
#FIXME
getInfo = 1
packageList = rpmUtils.getInstalledPackageList(progressCallback = lambda amount,
total: gtk.mainiteration(gtk.FALSE),
getInfo=getInfo)
selection = []
# FIXME
selectedPackages = packageList
## for row in range(self.regPackageArea.n_rows):
## rowData = self.regPackageArea.get_row_data(row)
## if rowData[0] == 1:
## selection.append(rowData[1])
## print "gh270"
## selectedPackages = []
## for pkg in packageList:
## if pkg[0] in selection:
## selectedPackages.append(pkg)
try:
rhnreg.sendPackages(self.systemId, selectedPackages)
except up2dateErrors.CommunicationError, e:
pwin.hide()
self.fatalError(_("Problem sending packages:\n") + e.errmsg)
except:
self.setArrowCursor()
pwin.hide()
dlg = messageWindow.ErrorDialog(_("Problem sending packages."))
return True
rhnreg.startRhnsd()
pwin.setProgress(5, 6)
li = None
try:
li = up2dateAuth.updateLoginInfo()
except rpclib.Fault, f:
if f.faultCode == -31:
self.serviceNotEnabled = 1
else:
self.fatalError(f.faultString,wrap=0)
return True
if li:
# see if we have any active channels
if li['X-RHN-Auth-Channels'] == []:
# no channels subscribe
self.noChannels = 1
pwin.setProgress(6,6)
pwin.hide()
rhnChannel.selected_channels = None
self.setArrowCursor()
return False
#FIXME: finish message hackery
def showHardwareDialog(self, button):
hdware = HardwareDialog()
def showPackageDialog(self, button):
pkgDlg = PackageDialog()
class NewAccountPage:
def __init__(self):
self.newAccountXml = gtk.glade.XML(gladefile,
"newAccountWindowVbox", domain="up2date")
self.newAccountXml.signal_autoconnect (
{ "onPrivacyButton2Clicked" : self.showPrivacyDialog,
"onCountryComboEntryChanged" : self.countryChanged,
})
def newAccountPagePrepare(self):
newAccountVbox = self.newAccountXml.get_widget("newAccountWindowVbox")
return newAccountVbox
def newAccountPageVerify(self):
self.pwEntry = self.newAccountXml.get_widget("newAccountPasswordEntry")
self.pwConfirmEntry = self.newAccountXml.get_widget("newAccountPasswordConfirmEntry")
self.unameEntry = self.newAccountXml.get_widget("newAccountUserEntry")
self.emailEntry = self.newAccountXml.get_widget("newAccountEmailEntry")
self.firstNameEntry = self.newAccountXml.get_widget("firstNameEntry")
self.lastNameEntry = self.newAccountXml.get_widget("lastNameEntry")
self.address1Entry = self.newAccountXml.get_widget("address1Entry")
self.address2Entry = self.newAccountXml.get_widget("address2Entry")
self.cityEntry = self.newAccountXml.get_widget("cityEntry")
self.zipEntry = self.newAccountXml.get_widget("zipEntry")
self.companyEntry = self.newAccountXml.get_widget("companyEntry")
self.stateComboEntry = self.newAccountXml.get_widget("stateCombo").entry
self.countryComboEntry = self.newAccountXml.get_widget("countryCombo").entry
global username, email, password
if self.unameEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter a user name."))
self.unameEntry.grab_focus()
return True
if len(self.unameEntry.get_text()) < 5:
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("User names must be at least 5 characters long"))
self.unameEntry.grab_focus()
return True
if self.pwEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter and verify a password."))
self.pwEntry.grab_focus()
return True
if len(self.pwEntry.get_text()) < 5:
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("Passwords must be at least 5 characters long"))
self.pwEntry.grab_focus()
return True
if self.pwConfirmEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter and verify a password."))
self.pwConfirmEntry.grab_focus()
return True
if self.emailEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter an email address."))
self.emailEntry.grab_focus()
return True
if not self.pwEntry.get_text() == self.pwConfirmEntry.get_text():
self.setArrowCursor()
dlg = messageWindow.WarningDialog(_("The two passwords you entered do not match.\nPlease re-type the second password."))
self.pwConfirmEntry.set_text("")
self.pwConfirmEntry.grab_focus()
return True
# verify they gave an email address
if not rhnreg.validateEmail(self.emailEntry.get_text()):
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter a valid e-mail address."))
# self.emailEntry.set_text("")
self.emailEntry.grab_focus()
return True
if self.firstNameEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter your first name."))
self.firstNameEntry.grab_focus()
return True
if self.lastNameEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter your last name."))
self.lastNameEntry.grab_focus()
return True
if self.address1Entry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter your address."))
self.address1Entry.grab_focus()
return True
if self.cityEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter your city."))
self.cityEntry.grab_focus()
return True
if self.zipEntry.get_text() == "":
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(_("You must enter your zip/postal code."))
self.zipEntry.grab_focus()
return True
username = self.unameEntry.get_text()
password = self.pwEntry.get_text()
email = self.emailEntry.get_text()
def getCaps(self):
caps = rhnreg.getCaps()
def newAccountPageApply(self):
# FIXME: move to apply
caps = self.getCaps()
global username, password, productInfo
productInfo = {}
try:
self.alreadyRegistered = rhnreg.reserveUser(username,
password)
except up2dateErrors.ValidationError, e:
self.setArrowCursor()
dlg = messageWindow.ErrorDialog(messageWindow.wrap_text(_("The server indicated an error:\n") + e.errmsg))
self.unameEntry.grab_focus()
return True
except up2dateErrors.CommunicationError, e:
self.setArrowCursor()
self.fatalError(_("There was an error communicating with the registration server. The message was:\n") + e.errmsg)
productInfo['first_name'] = self.firstNameEntry.get_text()
productInfo['last_name'] = self.lastNameEntry.get_text()
productInfo['company'] = self.companyEntry.get_text()
productInfo['address1'] = self.address1Entry.get_text()
productInfo['address2'] = self.address2Entry.get_text()
productInfo['city'] = self.cityEntry.get_text()
productInfo['state'] = self.stateComboEntry.get_text()
productInfo['country'] = self.countryComboEntry.get_text()
productInfo['zip'] = self.zipEntry.get_text()
productInfo['contact_email'] = self.newAccountXml.get_widget("contactOptInButton").get_active()
self.newAccount = 1
self.setArrowCursor()
return False
def showPrivacyDialog(self, button):
priv = PrivacyDialog()
def countryChanged(self, entry):
country = entry.get_text()
if country not in [_("United States"), _("Canada")]:
stateCombo = self.newAccountXml.get_widget("stateCombo").entry
stateCombo.set_text("")
class PrivacyDialog:
def __init__(self):
self.privXml = gtk.glade.XML(
gladefile,
"privacyDialog", domain="up2date")
self.dlg = self.privXml.get_widget("privacyDialog")
self.privXml.get_widget("okButton").connect("clicked", self.finish)
privacyArea = self.privXml.get_widget("privacyArea")
#privacyArea.delete_text(0, privacyArea.get_length())
try:
text = rhnreg.privacyText()
except up2dateErrors.CommunicationError, e:
self.mainWin.hide()
self.fatalError(_("Fatal error retrieving privacy statement:\n") + e.errmsg)
buffer = gtk.TextBuffer(None)
buffer.set_text(text)
privacyArea.set_buffer(buffer)
def finish(self, button):
self.dlg.hide()
self.rc = 1
class HardwareDialog:
def __init__(self):
self.hwXml = gtk.glade.XML(
gladefile,
"hardwareDialog", domain="up2date")
self.dlg = self.hwXml.get_widget("hardwareDialog")
self.hwXml.get_widget("okButton").connect("clicked", self.finish)
self.populateHardware()
def populateHardware(self):
# Read all hardware in
self.hardware = hardware.Hardware()
for hw in self.hardware:
if hw['class'] == 'CPU':
label = self.hwXml.get_widget("cpuLabel")
label.set_text(hw['model'])
label = self.hwXml.get_widget("speedLabel")
label.set_text(_("%d MHz") % hw['speed'])
elif hw['class'] == 'MEMORY':
label = self.hwXml.get_widget("ramLabel")
try:
label.set_text(_("%s megabytes") % hw['ram'])
except:
pass
elif hw['class'] == 'NETINFO':
label = self.hwXml.get_widget("hostnameLabel")
try:
label.set_text(hw['hostname'])
except:
pass
label = self.hwXml.get_widget("ipLabel")
try:
label.set_text(hw['ipaddr'])
except:
pass
label = self.hwXml.get_widget("versionLabel")
try:
distversion = up2dateUtils.getVersion()
except up2dateErrors.RpmError, e:
self.fatalError(e.errmsg)
label.set_text(distversion)
def finish(self, button):
self.dlg.hide()
self.rc = 1
class PackageDialog:
def __init__(self):
self.getPackageList()
self.swXml = gtk.glade.XML(
gladefile,
"packageDialog", domain="up2date")
self.dlg = self.swXml.get_widget("packageDialog")
self.swXml.get_widget("okButton").connect("clicked", self.finish)
self.createTree()
self.populatePackages()
def createTree(self):
# name-version-release, arch
self.packageStore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.packageStore.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.packageTreeView = self.swXml.get_widget("packageTreeView")
self.packageTreeView.set_model(self.packageStore)
self.packageTreeView.set_rules_hint(gtk.TRUE)
col = gtk.TreeViewColumn(_("Package"), gtk.CellRendererText(), text=0)
col.set_sort_column_id(0)
self.packageTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Arch"), gtk.CellRendererText(), text=1)
col.set_sort_column_id(1)
self.packageTreeView.append_column(col)
def getPackageList(self):
pwin = progress.Progress()
pwin.setLabel(_("Building a list of RPM packages installed on your system. Please wait."))
self.packageDialogPackages = rpmUtils.getInstalledPackageList(progressCallback = pwin.setProgress, getArch=1)
pwin.hide()
def populatePackages(self):
self.packageStore.clear()
for package in self.packageDialogPackages:
nvr = "%s-%s-%s" % (package[0], package[1], package[2])
arch = package[4]
iter = self.packageStore.append()
self.packageStore.set_value(iter, 0, nvr)
self.packageStore.set_value(iter, 1, arch)
def finish(self, button):
self.dlg.hide()
self.rc = 1
|