def setUp(self):
super(TestAuthentication, self).setUp()
with self._context("database"):
# Create few users and groups
gh = GroupHolder()
ah = AvatarHolder()
self._authMgr = AuthenticatorMgr()
for i in xrange(1, 3):
group = Group()
group.setName("fake-group-%d" % i)
group.setDescription("fake")
group.setEmail("*****@*****.**" % i)
group.setId("fake-group-%d" % i)
avatar = Avatar()
avatar.setName("fake-%d" % i)
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**" % i)
avatar.setId("fake-%d" % i)
avatar.activateAccount()
group.addMember(avatar)
ah.add(avatar)
gh.add(group)
identity = self._authMgr.createIdentity(
LoginInfo("fake-%d" % i, "fake-%d" % i), avatar, "Local")
self._authMgr.add(identity)
def create_dummy_user():
"""
Creates a dummy user for testing purposes
"""
avatar = Avatar()
avatar.setName("fake")
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**")
# registering user
ah = AvatarHolder()
ah.add(avatar)
# setting up the login info
li = LoginInfo("dummyuser", "dummyuser")
ih = AuthenticatorMgr()
userid = ih.createIdentity(li, avatar, "Local")
ih.add(userid)
# activate the account
avatar.activateAccount()
# since the DB is empty, we have to add dummy user as admin
minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
al = minfo.getAdminList()
al.grant(avatar)
dc = DefaultConference()
HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(dc)
return avatar
def testIdentities(self):
ah = AvatarHolder()
for i in xrange(1, 3):
self.assertEqual(
self._authMgr.getAvatar(LoginInfo("fake-%d" % i,
"fake-%d" % i)),
ah.getById("fake-%d" % i))
def _run(self, args):
avatar = Avatar()
name = raw_input("New administrator name: ").strip()
surname = raw_input("New administrator surname: ").strip()
organization = raw_input("New administrator organization: ").strip()
email = raw_input("New administrator email: ").strip()
login = raw_input("New administrator login: "******"New administrator password: "******"Retype administrator password: "******"Sorry, passwords do not match")
avatar.setName(name)
avatar.setSurName(surname)
avatar.setOrganisation(organization)
avatar.setLang("en_GB")
avatar.setEmail(email)
self.printUserInfo(avatar)
if console.yesno(
"Are you sure to create and grant administrator privileges to this user?"
):
avatar.activateAccount()
loginInfo = LoginInfo(login, password)
authMgr = AuthenticatorMgr()
userid = authMgr.createIdentity(loginInfo, avatar, "Local")
authMgr.add(userid)
adminList = info.HelperMaKaCInfo.getMaKaCInfoInstance(
).getAdminList()
AvatarHolder().add(avatar)
adminList.grant(avatar)
print "New administrator created successfully with id: %s" % avatar.getId(
)
def _getAnswer(self):
li = LoginInfo(self._username, self._password)
auth = AuthenticatorMgr()
av = auth.getAvatar(li)
if not av:
from MaKaC.services.interface.rpc.common import ServiceError
raise ServiceError("Wrong login or password")
elif not av.isActivated():
from MaKaC.services.interface.rpc.common import ServiceError
raise ServiceError(
"Your account is not active. Please activate it and retry.")
else:
self._getSession().setUser(av)
return '%s OK %s' % (self._username, datetime.datetime.now())
def create_user(name, login, authManager, set_password=False):
avatar = Avatar()
avatar.setName(name)
avatar.setSurName(name)
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**" % name)
# setting up the login info
li = LoginInfo(login, login if set_password else None)
userid = authManager.createIdentity(li, avatar, "Local")
authManager.add(userid)
# activate the account
avatar.activateAccount()
return avatar
def _process(self):
self._disableCaching()
#Check for automatic login
auth = AuthenticatorMgr()
av = auth.autoLogin(self)
if av:
url = self._returnURL
tzUtil = timezoneUtils.SessionTZ(av)
tz = tzUtil.getSessionTZ()
self._getSession().setVar("ActiveTimezone", tz)
self._getSession().setUser(av)
if Config.getInstance().getBaseSecureURL().startswith('https://'):
url = str(url).replace('http://', 'https://')
self._redirect(url, noCache=True)
if not self._signIn:
p = signIn.WPSignIn(self)
return p.display(returnURL=self._returnURL)
else:
li = LoginInfo(self._login, self._password)
av = auth.getAvatar(li)
if not av:
p = signIn.WPSignIn(self,
login=self._login,
msg=_("Wrong login or password"))
return p.display(returnURL=self._returnURL)
elif not av.isActivated():
if av.isDisabled():
self._redirect(urlHandlers.UHDisabledAccount.getURL(av))
else:
self._redirect(urlHandlers.UHUnactivatedAccount.getURL(av))
return _(
"your account is not activate\nPlease active it and retry")
else:
url = self._returnURL
#raise(str(dir(av)))
self._getSession().setUser(av)
tzUtil = timezoneUtils.SessionTZ(av)
tz = tzUtil.getSessionTZ()
self._getSession().setVar("ActiveTimezone", tz)
if self._userId != "":
if "?" in url:
url += "&userId=%s" % self._userId
else:
url += "?userId=%s" % self._userId
if Config.getInstance().getBaseSecureURL().startswith('https://'):
url = str(url).replace('http://', 'https://')
self._redirect(url, noCache=True)
def _process(self):
#Check for automatic login
authManager = AuthenticatorMgr()
if (authManager.isSSOLoginActive() and len(authManager.getList()) == 1
and not Config.getInstance().getDisplayLoginPage()):
self._redirect(
urlHandlers.UHSignInSSO.getURL(
authId=authManager.getDefaultAuthenticator().getId()))
return
li = LoginInfo(self._login, self._password)
av = authManager.getAvatar(li)
self._responseUtil.content_type = 'application/json'
if not av:
return '{"success":false,"message":"User not authenticated or found"}'
elif not av.isActivated():
return '{"success":false,"message":"User not activated"}'
else:
return '{"success":true}'
def user_create(grant_admin):
"""Creates new user"""
avatar = Avatar()
user_type = 'user' if not grant_admin else 'admin'
print()
name = prompt("First name")
surname = prompt("Last name")
organization = prompt("Affiliation")
print()
login = prompt("Enter username")
email = prompt_email().encode('utf-8')
if email is None:
return
password = prompt_pass().encode('utf-8')
if password is None:
return
avatar.setName(name)
avatar.setSurName(surname)
avatar.setOrganisation(organization)
avatar.setLang("en_GB")
avatar.setEmail(email)
print_user_info(avatar)
if prompt_bool(cformat("%{yellow}Create the new {}?").format(user_type), default=True):
from MaKaC.authentication import AuthenticatorMgr
avatar.activateAccount()
login_info = LoginInfo(login, password)
auth_mgr = AuthenticatorMgr()
try:
user_id = auth_mgr.createIdentity(login_info, avatar, "Local")
auth_mgr.add(user_id)
AvatarHolder().add(avatar)
if grant_admin:
admin_list = HelperMaKaCInfo.getMaKaCInfoInstance().getAdminList()
admin_list.grant(avatar)
success("New {} created successfully with ID: {}".format(user_type, avatar.getId()))
except UserError as e:
error("Error: {}".format(str(e)))
def _process(self):
li = LoginInfo(self._login, self._password)
av = AuthenticatorMgr().getAvatar(li)
value = "OK"
message = ""
if not av:
value = "ERROR"
message = "Login failed"
elif not av.isActivated():
if av.isDisabled():
value = "ERROR"
message = "Acount is disabled"
else:
value = "ERROR"
message = "Acount is not activated"
else:
value = "OK"
message = "Login succesful"
session.user = av
return self._createResponse(value, message)
def _import(self, file):
# check Registration period
import datetime
import pytz
utc = pytz.UTC
startDate = self._conf.getRegistrationForm().getStartRegistrationDate()
endDate = self._conf.getRegistrationForm().getEndRegistrationDate()
current = datetime.datetime.now()
current = utc.localize(current)
if (current < startDate or current > endDate):
raise NoReportError(
"Import registrants not authorized, outside registration period.")
reader = csv.DictReader(file)
i = 1
errors = []
successfuls = []
unsuccessfuls = []
for row in reader:
try:
# row['Email'] = row['Email'].lower()
self._processImportData(row)
matchedUsers = AvatarHolder().match({"email": row['Email']},
exact=1)
if matchedUsers:
user = matchedUsers[0]
elif ('Account Creation' in row) and row['Account Creation'].lower(
) == 'yes': # account creation
avData = self._mapAvatar(row)
user = Avatar(avData)
user.activateAccount()
login_info = LoginInfo(row['Login'], row['Password'])
auth_mgr = AuthenticatorMgr()
user_id = auth_mgr.createIdentity(login_info, user, "Local")
auth_mgr.add(user_id)
AvatarHolder().add(user)
else:
user = None
if not (user):
reg = Registrant() # new registration
self._conf.addRegistrant(reg, user)
else:
if user.isRegisteredInConf(self._conf):
reg = self._conf.getRegistrantsByEmail(user.getEmail())
else: # not registered, new registration
reg = Registrant()
reg.setAvatar(user)
self._conf.addRegistrant(reg, user)
user.addRegistrant(reg)
regData = self._mapRegistrant(row)
regData['import'] = 'import'
reg.setValues(regData, user)
self._setAffiliation(reg)
successfuls.append(reg.getFullName())
except Exception:
errors.append(i)
unsuccessfuls.append(
row["Surname"] + ", " + row["First Name"]
) # exception : reg or user might not be defined yet
finally:
i += 1
self.logimport(successfuls, unsuccessfuls)
return errors
def start(self, obj):
super(RoomBooking_Feature, self).start(obj)
with obj._context('database'):
# Tell indico to use the current database for roombooking stuff
minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
cfg = Configuration.Config.getInstance()
minfo.setRoomBookingDBConnectionParams(cfg.getDBConnectionParams())
obj._ph.getById('RoomBooking').setActive(True)
DALManagerCERN.connect()
initializeRoomBookingDB("Universe", force=False)
DALManagerCERN.disconnect()
# do not use the method for it as it tries to re-create jsvars and fails
minfo._roomBookingModuleActive = True
DALManagerCERN.connect()
# Create dummy avatars in obj._avatarN
ah = AvatarHolder()
obj._avatars = []
for i in xrange(1, 5):
avatar = Avatar()
avatar.setName("fake-%d" % i)
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**" % i)
avatar.setId("rb-fake-%d" % i)
# setting up the login info
li = LoginInfo("fake-%d" % i, "fake-%d" % i)
ih = AuthenticatorMgr()
userid = ih.createIdentity(li, avatar, "Local")
ih.add(userid)
# activate the account
avatar.activateAccount()
ah.add(avatar)
obj._avatars.append(avatar)
setattr(obj, '_avatar%d' % i, avatar)
# Create dummy rooms in obj._roomN - owners are fake1 and fake2 (r1 has f1, r2 has f2, r3 has f1, ...)
location = Location.getDefaultLocation()
obj._rooms = []
for i in xrange(1, 8):
room = location.newRoom()
room.locationName = location.friendlyName
room.name = 'DummyRoom%d' % i
room.site = 'a'
room.building = 1
room.floor = 'b'
room.roomNr = 'c'
room.latitude = ''
room.longitude = ''
room.isActive = True
room.isReservable = True
room.resvsNeedConfirmation = False
room.responsibleId = 'rb-fake-%d' % (((i - 1) % 2) + 1)
room.whereIsKey = 'Nowhere'
room.telephone = '123456789'
room.capacity = 10
room.division = ''
room.surfaceArea = 50
room.comments = ''
room.setEquipment([])
room.setAvailableVC([])
room.insert()
obj._rooms.append(room)
setattr(obj, '_room%d' % i, room)
