def __setHistory(self,name=False):
gLogger.info("__setHistory(%s) function" % name)
if not name:
return S_ERROR( "Name of the layout to save in history is absent" )
upc = UserProfileClient( "Default", getRPCClient )
profile_name = USER_PROFILE_NAME + ".History"
gLogger.info("upc.retrieveVar(%s)" % profile_name)
result = upc.retrieveVar(profile_name)
gLogger.debug(result)
if not result["OK"]:
result = dict()
result["Value"] = dict()
data = result["Value"]
try:
data = list(data)
except:
data = list()
data.append(name)
while len(data) > 50:
data.popleft()
gLogger.info("upc.storeVar(%s,%s)" % (profile_name,data))
result = upc.storeVar(profile_name,data)
gLogger.debug(result)
if not result["OK"]:
return S_ERROR( result["Message"] )
return S_OK( result["Value"] )
def __setBookmarks(self,name):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {"success":"false","error":"The name \"" + name + "\" is reserved, operation failed"}
if not request.params.has_key("columns") and len(request.params["columns"]) <= 0:
return {"success":"false","error":"Parameter 'Columns' is absent"}
if not request.params.has_key("refresh") and len(request.params["refresh"]) <= 0:
return {"success":"false","error":"Parameter 'Refresh' is absent"}
upc = UserProfileClient( "Summary", getRPCClient )
result = upc.retrieveVar( "Bookmarks" )
if result["OK"]:
data = result["Value"]
else:
data = {}
data["defaultLayout"] = name
if not data.has_key("layouts"):
data["layouts"] = {}
data["layouts"][name] = {}
if request.params.has_key("plots") and len(request.params["plots"]) > 0:
data["layouts"][name]["url"] = str(request.params["plots"])
else:
data["layouts"][name]["url"] = ""
data["layouts"][name]["columns"] = str(request.params["columns"])
data["layouts"][name]["refresh"] = str(request.params["refresh"])
gLogger.info("\033[0;31m Data to save: \033[0m",data)
result = upc.storeVar( "Bookmarks", data )
gLogger.info("\033[0;31m UserProfile response: \033[0m",result)
if result["OK"]:
return self.__getBookmarks()
else:
return {"success":"false","error":result["Message"]}
def __lastUsed(self):
gLogger.info("Running lastUsed()")
msg = "lastUsed() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__getHistory("Load")
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
history = result["Value"]
if not len(history) > 0:
err = "Load history is empty"
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
args = history[0]
name = args["name"]
user = args["user"]
group = args["group"]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveVarFromUser(user, group, name)
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
layout = result["Value"]
for i in LOAD_LAYOUT_ARGS: # Add params to layout if they are absent
if not layout.has_key(i):
layout[i] = args[i]
gLogger.info("Result %s: %s" % (msg, layout))
return S_OK(layout)
def __lastUsed( self ):
gLogger.info( "Running lastUsed()" )
msg = "lastUsed() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__getHistory( "Load" )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
history = result[ "Value" ]
if not len( history ) > 0:
err = "Load history is empty"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
args = history[ 0 ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveVarFromUser( user , group, name )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
layout = result[ "Value" ]
for i in LOAD_LAYOUT_ARGS : # Add params to layout if they are absent
if not layout.has_key( i ):
layout[ i ] = args[ i ]
gLogger.info( "Result %s: %s" % ( msg , layout ) )
return S_OK( layout )
def all(self):
result = list()
for i in [ USER_PROFILE_NAME , "Default" ]:
upc = UserProfileClient( i , getRPCClient )
allvar = upc.retrieveAllVars()
result.append( allvar )
return result
def __getUserLayout(self):
gLogger.info("Running getUserLayout()")
msg = "getUserLayout() for %s@%s" % (getUsername(), getSelectedGroup())
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveAllVars()
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
layouts = result["Value"]
data = list()
for name, value in layouts.items():
result = self.__getPermissions(name)
if not result["OK"]:
perm = result["Message"]
else:
perm = result["Value"]
if perm.has_key("ReadAccess"):
perm = perm["ReadAccess"]
else:
perm = "Undefined"
if value.has_key("group"):
group = value["group"]
else:
group = "Undefined"
perm = perm.capitalize()
data.append({"name": name, "permission": perm, "group": group})
gLogger.info("Result %s: %s" % (msg, data))
return {"success": "true", "result": data}
def __getHistory( self , state ):
"""
Just get the history based on state
Return resulting list
"state" can be either "Save" or "Load"
"""
gLogger.info( "Running getHistory( %s )" % state )
msg = "getHistory() for %s@%s" % ( getUsername() , getSelectedGroup() )
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions( opt , 5 )
upc = UserProfileClient( "Default" , getRPCClient )
group = str( getSelectedGroup() )
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar( profile_name )
gLogger.info( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
history = list()
else:
history = result[ "Value" ]
if not isinstance( history , list ):
err = "List expected at: %s" % profile_name
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
if( len( history ) > history_length ):
history = result[ history_length ]
gLogger.info( "Result %s: %s" % ( msg , history ) )
return S_OK( history )
def all(self):
result = list()
for i in [USER_PROFILE_NAME, "Default"]:
upc = UserProfileClient(i, getRPCClient)
allvar = upc.retrieveAllVars()
result.append(allvar)
return result
def __loadLayout(self):
gLogger.info("Running loadLayout()")
msg = "loadLayout() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__params2string(LOAD_LAYOUT_ARGS)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
args = result["Value"]
name = args["name"]
user = args["user"]
group = args["group"]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveVarFromUser(user, group, name)
gLogger.debug(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
err = "No data found for '%s' by %s@%s" % (name, user, group)
gLogger.error("Result %s: %s" % (msg, err))
return {"success": "false", "error": err}
layout = result["Value"]
for i in LOAD_LAYOUT_ARGS: # Add params to layout if they are absent
if not layout.has_key(i):
layout[i] = args[i]
result = self.__setHistory(args, "Load")
history = dict()
if not result["OK"]:
history["Load"] = result["Message"]
else:
history["Load"] = result["Value"]
gLogger.info("Result %s: %s AND %s" % (msg, layout, history))
return {"success": "true", "result": layout, "history": history}
def __getBookmarks(self,name=""):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {"success":"false","error":"The name \"" + name + "\" is reserved, operation failed"}
upc = UserProfileClient( "Summary", getRPCClient )
result = upc.retrieveVar( "Bookmarks" )
gLogger.info("\033[0;31m UserProfile getBookmarks response: \033[0m",result)
if result["OK"]:
result = result["Value"]
if name != "":
result["defaultLayout"] = name
save = upc.storeVar( "Bookmarks", result )
gLogger.info("\033[0;31m saving new default layout \033[0m",name)
if not save["OK"]:
return {"success":"false","error":save["Message"]}
elif name == "" and not result.has_key("defaultLayout"):
result["defaultLayout"] = ""
if result.has_key("layouts"):
layouts = ""
for i in result["layouts"]:
layouts = layouts + str(i) + ";"
result["layoutNames"] = layouts
c.result = {"success":"true","result":result}
else:
if result['Message'].find("No data for") != -1:
c.result = {"success":"true","result":{}}
else:
c.result = {"success":"false","error":result["Message"]}
return c.result
def __delHistory(self,name=False):
gLogger.info("__delHistory(%s) function" % name)
upc = UserProfileClient( "Default", getRPCClient )
profile_name = USER_PROFILE_NAME + ".History"
gLogger.info("upc.retrieveVar(%s)" % profile_name)
result = upc.retrieveVar(profile_name)
gLogger.debug(result)
if not result["OK"]:
return S_ERROR( result["Message"] )
data = result["Value"]
try:
data = list(data)
except:
return S_ERROR( "Failed to convert '%s' to list" % data )
if name:
if data.count(name) > 0:
while data.count(name) > 0:
data.remove(name)
else:
data = list()
while len(data) > 50:
data.popleft()
gLogger.info("upc.storeVar(%s,%s)" % (profile_name,data))
result = upc.storeVar(profile_name,data)
gLogger.debug(result)
if not result["OK"]:
return S_ERROR( result["Message"] )
return S_OK( result["Value"] )
def __getData(self,name=False):
gLogger.info("__getData(%s) function" % name)
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
gLogger.info("upc.retrieveAllVars()")
result = upc.retrieveAllVars()
gLogger.debug(result)
if not result["OK"]:
if result['Message'].find("No data for") != -1:
return {"success":"true","result":{}}
return {"success":"false","error":result["Message"]}
callback = dict()
callback["layouts"] = result["Value"]
keys = result["Value"].keys()
callback["layoutNames"] = ";".join(keys)
if not name:
last = self.__lastHistory()
if not last["OK"]:
last = ""
else:
last = last["Value"]
else:
last = name
callback["defaultLayout"] = last
if name:
result = self.__setHistory(name)
if not result["OK"]:
gLogger.error(result["Message"])
return {"success":"true","result":callback}
def __getHistory(self, state):
"""
Just get the history based on state
Return resulting list
"state" can be either "Save" or "Load"
"""
gLogger.info("Running getHistory( %s )" % state)
msg = "getHistory() for %s@%s" % (getUsername(), getSelectedGroup())
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions(opt, 5)
upc = UserProfileClient("Default", getRPCClient)
group = str(getSelectedGroup())
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar(profile_name)
gLogger.info(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
history = list()
else:
history = result["Value"]
if not isinstance(history, list):
err = "List expected at: %s" % profile_name
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
if (len(history) > history_length):
history = result[history_length]
gLogger.info("Result %s: %s" % (msg, history))
return S_OK(history)
def __delBookmarks(self,name):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {"success":"false","error":"The name \"" + name + "\" is reserved, please choose another name. Operation failed"}
upc = UserProfileClient( "Summary", getRPCClient )
result = upc.retrieveVar( "Bookmarks" )
if result["OK"]:
data = result["Value"]
else:
data = {}
gLogger.info("\033[0;31m data: \033[0m",data)
if data.has_key("layouts"):
if name in data["layouts"]:
del data["layouts"][name]
else:
return {"success":"false","error":"Can't delete not existing layout: \"" + name + "\""}
else:
return {"success":"false","error":"Can't read existing layouts, operation failed"}
if len(data["layouts"]) > 0:
data["defaultLayout"] = data["layouts"].keys()[0]
else:
data["defaultLayout"] = ""
gLogger.info("\033[0;31m data: \033[0m",data)
result = upc.storeVar( "Bookmarks", data )
gLogger.info("\033[0;31m result: \033[0m",result)
if result["OK"]:
return self.__getBookmarks()
else:
return {"success":"false","error":result["Message"]}
def __getBookmarks(self, name=""):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {
"success": "false",
"error":
"The name \"" + name + "\" is reserved, operation failed"
}
upc = UserProfileClient("Summary", getRPCClient)
result = upc.retrieveVar("Bookmarks")
gLogger.info("\033[0;31m UserProfile getBookmarks response: \033[0m",
result)
if result["OK"]:
result = result["Value"]
if name != "":
result["defaultLayout"] = name
save = upc.storeVar("Bookmarks", result)
gLogger.info("\033[0;31m saving new default layout \033[0m",
name)
if not save["OK"]:
return {"success": "false", "error": save["Message"]}
elif name == "" and not result.has_key("defaultLayout"):
result["defaultLayout"] = ""
if result.has_key("layouts"):
layouts = ""
for i in result["layouts"]:
layouts = layouts + str(i) + ";"
result["layoutNames"] = layouts
c.result = {"success": "true", "result": result}
else:
if result['Message'].find("No data for") != -1:
c.result = {"success": "true", "result": {}}
else:
c.result = {"success": "false", "error": result["Message"]}
return c.result
def __getBookmarks(self):
"""returns the bookkmarks"""
self.getWidget().waitCursor()
upc = UserProfileClient("Bookkeeping", RPCClient)
bookmarks = upc.retrieveVar("Bookmarks")
self.getWidget().arrowCursor()
return bookmarks
def __getUserLayout( self ) :
gLogger.info( "Running getUserLayout()" )
msg = "getUserLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveAllVars()
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
layouts = result[ "Value" ]
data = list()
for name , value in layouts.items():
result = self.__getPermissions( name )
if not result[ "OK" ]:
perm = result[ "Message" ]
else:
perm = result[ "Value" ]
if perm.has_key( "ReadAccess" ):
perm = perm[ "ReadAccess" ]
else:
perm = "Undefined"
if value.has_key( "group" ):
group = value[ "group" ]
else:
group = "Undefined"
data.append( { "name" : name , "permission" : perm , "group" : group } )
gLogger.info( "Result %s: %s" % ( msg , data ) )
return { "success" : "true" , "result" : data }
def __loadLayout( self ):
gLogger.info( "Running loadLayout()" )
msg = "loadLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__params2string( LOAD_LAYOUT_ARGS )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
args = result[ "Value" ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveVarFromUser( user , group, name )
gLogger.debug( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
err = "No data found for '%s' by %s@%s" % ( name , user , group )
gLogger.error( "Result %s: %s" % ( msg , err ) )
return { "success" : "false" , "error" : err }
layout = result[ "Value" ]
for i in LOAD_LAYOUT_ARGS : # Add params to layout if they are absent
if not layout.has_key( i ):
layout[ i ] = args[ i ]
result = self.__setHistory( args , "Load" )
history = dict()
if not result[ "OK" ]:
history[ "Load" ] = result[ "Message" ]
else:
history[ "Load" ] = result[ "Value" ]
gLogger.info( "Result %s: %s AND %s" % ( msg , layout , history ) )
return { "success" : "true" , "result" : layout , "history" : history }
def registerRequest(self, dn, email):
"""
Save hash made of email address to a profile REG_PROFILE_NAME
Return S_OK, S_ERROR
"""
upc = UserProfileClient(REG_PROFILE_NAME, getRPCClient)
return upc.storeVar(dn, email)
def __delAllBookmarks(self):
upc = UserProfileClient("Summary", getRPCClient)
data = {}
result = upc.storeVar("Bookmarks", data)
if result["OK"]:
return self.__getBookmarks()
else:
return {"success": "false", "error": result["Message"]}
def __delAllBookmarks(self):
upc = UserProfileClient( "Summary", getRPCClient )
data = {}
result = upc.storeVar( "Bookmarks", data )
if result["OK"]:
return self.__getBookmarks()
else:
return {"success":"false","error":result["Message"]}
def isRequested(self, dn):
"""
Checks if the email already saved as registration request key or not
Return True or False
"""
upc = UserProfileClient(REG_PROFILE_NAME, getRPCClient)
return upc.retrieveVar(dn)
def __getUP(self):
try:
obj = self.request.arguments['obj'][-1]
app = self.request.arguments['app'][-1]
except KeyError as excp:
raise WErr(400, "Missing %s" % excp)
print "UserProfileClient"
print UserProfileClient("Web/%s/%s" % (obj, app))
return UserProfileClient("Web/%s/%s" % (obj, app))
def isRequested( self , dn ):
"""
Checks if the email already saved as registration request key or not
Return True or False
"""
upc = UserProfileClient( REG_PROFILE_NAME , getRPCClient )
return upc.retrieveVar( dn )
def registerRequest( self , dn , email ):
"""
Save hash made of email address to a profile REG_PROFILE_NAME
Return S_OK, S_ERROR
"""
upc = UserProfileClient( REG_PROFILE_NAME , getRPCClient )
return upc.storeVar( dn , email )
def kaboom(self):
uList = [ str( getUsername() ) ]
result = list()
for i in [ USER_PROFILE_NAME , "Default" ]:
upc = UserProfileClient( i , getRPCClient )
tmp = upc.deleteProfiles( uList )
allvar = upc.retrieveAllVars()
result.append( allvar )
return result
def kaboom(self):
uList = [str(getUsername())]
result = list()
for i in [USER_PROFILE_NAME, "Default"]:
upc = UserProfileClient(i, getRPCClient)
tmp = upc.deleteProfiles(uList)
allvar = upc.retrieveAllVars()
result.append(allvar)
return result
def layoutAvailable(self):
upProfileName = "Summary"
upc = UserProfileClient("Summary", getRPCClient)
result = upc.listAvailableVars()
gLogger.info("\033[0;31m listAvailableVars: \033[0m", result)
if result["OK"]:
result = result["Value"]
resultList = []
for i in result:
resultList.append({'name': i[3], 'owner': i[0]})
return {"success": "true", "result": resultList, "total": "55"}
def __convert(self):
gLogger.info("START of DATA CONVERTION")
upc = UserProfileClient( "Default", getRPCClient )
profile_name = USER_PROFILE_NAME + ".History"
gLogger.info("1) Init of history var")
result = upc.storeVar(profile_name,list())
if not result["OK"]:
gLogger.info("Initialization of history records has failed")
return S_OK()
gLogger.info("Done")
gLogger.info("2) Get old data")
result = self.__getData()
if not result["result"]:
gLogger.info("getData returns no result")
return S_OK()
gLogger.info("Done")
gLogger.info("3) Is bookmark exists")
data = result["result"]["layouts"]
if not data.has_key("Bookmarks"):
gLogger.info("No old Bookmarks found")
return S_OK()
data = data["Bookmarks"]
gLogger.info("Done")
gLogger.info("4) Is layouts exists")
if not data.has_key("layouts"):
gLogger.info("No layouts to convert")
return S_OK()
layouts = data["layouts"]
gLogger.info("Done")
gLogger.info("5) Layouts is dict")
try:
layouts = dict(layouts)
except:
gLogger.info("Layouts '%s' is not dictionary" % layouts)
return S_OK()
gLogger.info("Done")
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
gLogger.info("6) Deleting old data")
old = self.__delData("Bookmarks")
gLogger.info("Should be empty: %s" % old)
gLogger.info("Done")
gLogger.info("8) Saving old data to new")
for i in layouts:
gLogger.info("Name: '%s'" % i)
gLogger.info("Data: '%s'" % layouts[i])
result = upc.storeVar(i,layouts[i])
gLogger.info(result)
if data.has_key("defaultLayout"):
name = data["defaultLayout"]
result = self.__setHistory(name)
if not result["OK"]:
gLogger.error(result["Message"])
gLogger.info("GOOD END of DATA CONVERTION")
return S_OK()
def layoutAvailable(self):
upProfileName = "Summary"
upc = UserProfileClient( "Summary", getRPCClient )
result = upc.listAvailableVars()
gLogger.info("\033[0;31m listAvailableVars: \033[0m",result)
if result["OK"]:
result = result["Value"]
resultList = []
for i in result:
resultList.append({'name':i[3],'owner':i[0]})
return {"success":"true","result":resultList,"total":"55"}
def __delData(self,name=False):
gLogger.info("__delData(%s) function" % name)
if not name:
return {"success":"false","error":"Name of the layout is absent"}
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
gLogger.info("upc.deleteVar(%s)" % name)
result = upc.deleteVar(name)
gLogger.debug(result)
if not result["OK"]:
return {"success":"false","error":result["Message"]}
result = self.__delHistory(name)
if not result["OK"]:
gLogger.error(result["Message"])
return self.__getData()
def display(self):
checkUserCredentials()
dn = getUserDN()
user = getUsername()
group = getSelectedGroup()
gLogger.always("User: %s, Group: %s, DN: %s" % (user, group, dn))
templates = ["reg_%s.mako" % i for i in ["done", "form", "info"]]
html = [
"reg_%s.html" % i
for i in ["footer", "header", "conditions", "form", "done"]
]
files = templates + html
basedir = os.path.join(rootPath, "Web", "dirac", "templates")
for i in files:
f = os.path.join(basedir, i)
if not os.path.exists(f):
gLogger.error("File does not exists: %s" % f)
return render("web/External.mako")
if dn and user == "anonymous":
upc = UserProfileClient("Registration", getRPCClient)
result = upc.retrieveVar(dn)
if result["OK"]:
c.sent = result["Value"]
return render("/reg_done.mako")
else:
return render("/reg_form.mako")
if not dn or dn == "":
return render("/reg_info.mako")
if "site" not in request.params:
c.select = gConfig.getValue("/Website/DefaultExternalURL",
"http://diracgrid.org")
return render("web/External.mako")
# No idea what this code should do...
if request.params.has_key("site") and len(request.params["site"]) > 0:
if str(request.params["site"]) != "All":
c.select = str(request.params["site"])
gLogger.debug("Request's body:")
for key in request.params.keys():
if not key == "site" and len(request.params[key]) > 0:
c.select = c.select + "&" + key + "=" + request.params[
key]
try:
gLogger.debug("%s - %s" %
(key, request.params[key]))
except Exception, x:
gLogger.error("Exception: %s" % str(x))
pass
def alreadyRequested( self , email = False ):
"""
Checks if the email already saved as registration request key or not
Return True or False
"""
if not email:
return True
upc = UserProfileClient( REG_PROFILE_NAME , getRPCClient )
result = upc.retrieveVar( email )
gLogger.info( result )
if result[ "OK" ]:
return True
return False
def __getPermissions( self , name = False ):
gLogger.info( "getPermissions( %s )" % name )
msg = "getPermissions() for %s@%s" % ( getUsername() , getSelectedGroup() )
if not name:
err = "'name' argument for getPermissions function is absent"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.getVarPermissions( name )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , result[ "Value" ] ) )
return S_OK( result[ "Value" ] )
def __getAtomicData(self,name=False):
gLogger.info("__getAtomicData(%s) function" % name)
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
if not name:
gLogger.info("upc.retrieveAllVars()")
result = upc.retrieveAllVars()
else:
gLogger.info("upc.retrieveVar(%s)" % name)
result = upc.retrieveVar(name)
gLogger.debug(result)
if not result["OK"]:
if result['Message'].find("No data for") != -1:
return {"success":"true","result":{}}
return {"success":"false","error":result["Message"]}
result = result["Value"]
return {"success":"true","result":result}
def __delAllData(self):
gLogger.info("__delAllData(%s) function")
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
username = getUsername()
if not type(username) == type({}):
username = list(username)
gLogger.info("upc.deleteProfiles(%s)" % username)
result = upc.deleteProfiles(username)
gLogger.debug(result)
if not result["OK"]:
gLogger.error(result["Message"])
return {"success":"false","error":result["Message"]}
result = self.__delHistory()
if not result["OK"]:
gLogger.error(result["Message"])
return self.__getData()
def __saveLayout( self ):
gLogger.info( "Running saveLayout()" )
msg = "saveLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__params2string( SAVE_LAYOUT_ARGS )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
args = result[ "Value" ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
permissions = args[ "permissions" ]
result = self.__parsePermissions( name , permissions )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
permissions = result[ "Value" ]
data = dict()
for key , value in request.params.items():
try:
if len( value ) > 0:
data[ key ] = str( value )
except:
pass
if not len( data ) > 0:
err = "Data to store has zero length"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return { "success" : "false" , "error" : err }
for i in LOAD_LAYOUT_ARGS : # Add vital params to layout if they are absent
if not data.has_key( i ):
data[ i ] = args[ i ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.storeVar( name , data , permissions )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
result = self.__setHistory( args , "Save" )
history = dict()
if not result[ "OK" ]:
history[ "Save" ] = result[ "Message" ]
else:
history[ "Save" ] = result[ "Value" ]
gLogger.info( "Result %s: %s AND %s" % ( msg , data , history ) )
return { "success" : "true" , "result" : data , "history" : history }
def __saveLayout(self):
gLogger.info("Running saveLayout()")
msg = "saveLayout() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__params2string(SAVE_LAYOUT_ARGS)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
args = result["Value"]
name = args["name"]
user = args["user"]
group = args["group"]
permissions = args["permissions"]
result = self.__parsePermissions(name, permissions)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
permissions = result["Value"]
data = dict()
for key, value in request.params.items():
try:
if len(value) > 0:
data[key] = str(value)
except:
pass
if not len(data) > 0:
err = "Data to store has zero length"
gLogger.error("Result %s: %s" % (msg, err))
return {"success": "false", "error": err}
for i in LOAD_LAYOUT_ARGS: # Add vital params to layout if they are absent
if not data.has_key(i):
data[i] = args[i]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.storeVar(name, data, permissions)
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
result = self.__setHistory(args, "Save")
history = dict()
if not result["OK"]:
history["Save"] = result["Message"]
else:
history["Save"] = result["Value"]
gLogger.info("Result %s: %s AND %s" % (msg, data, history))
return {"success": "true", "result": data, "history": history}
def __lastHistory(self):
gLogger.info("__lastHistory() function")
upc = UserProfileClient( "Default", getRPCClient )
profile_name = USER_PROFILE_NAME + ".History"
gLogger.info("upc.retrieveVar(%s)" % profile_name)
result = upc.retrieveVar(profile_name)
gLogger.debug(result)
if not result["OK"]:
return S_ERROR( result["Message"] )
data = result["Value"]
try:
data = list(data)
except:
return S_ERROR( "Failed to convert %s to list" % data )
last = ""
if len(data) > 0:
last = data.pop()
return S_OK( last )
def __setBookmarks(self, name):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {
"success": "false",
"error":
"The name \"" + name + "\" is reserved, operation failed"
}
if not request.params.has_key("columns") and len(
request.params["columns"]) <= 0:
return {
"success": "false",
"error": "Parameter 'Columns' is absent"
}
if not request.params.has_key("refresh") and len(
request.params["refresh"]) <= 0:
return {
"success": "false",
"error": "Parameter 'Refresh' is absent"
}
upc = UserProfileClient("Summary", getRPCClient)
result = upc.retrieveVar("Bookmarks")
if result["OK"]:
data = result["Value"]
else:
data = {}
data["defaultLayout"] = name
if not data.has_key("layouts"):
data["layouts"] = {}
data["layouts"][name] = {}
if request.params.has_key("plots") and len(
request.params["plots"]) > 0:
data["layouts"][name]["url"] = str(request.params["plots"])
else:
data["layouts"][name]["url"] = ""
data["layouts"][name]["columns"] = str(request.params["columns"])
data["layouts"][name]["refresh"] = str(request.params["refresh"])
gLogger.info("\033[0;31m Data to save: \033[0m", data)
result = upc.storeVar("Bookmarks", data)
gLogger.info("\033[0;31m UserProfile response: \033[0m", result)
if result["OK"]:
return self.__getBookmarks()
else:
return {"success": "false", "error": result["Message"]}
def getUserProfileClient(controller=False, action=False):
routingDict = request.environ['wsgiorg.routing_args'][1]
if not controller:
controller = routingDict['controller']
if not action:
action = routingDict['action']
actionPath = str("%s/%s" % (controller, action))
return UserProfileClient(actionPath,
rpcClient=getRPCClient(
"Framework/UserProfileManager", timeout=600))
def display(self):
checkUserCredentials()
dn = getUserDN()
user = getUsername()
group = getSelectedGroup()
gLogger.always( "User: %s, Group: %s, DN: %s" % ( user , group , dn ) )
templates = [ "reg_%s.mako" % i for i in [ "done" , "form" , "info" ] ]
html = [ "reg_%s.html" % i for i in [ "footer" , "header" , "conditions" , "form" , "done" ] ]
files = templates + html
basedir = os.path.join( rootPath , "Web" , "dirac" , "templates" )
for i in files:
f = os.path.join( basedir , i )
if not os.path.exists( f ):
gLogger.error( "File does not exists: %s" % f )
return render( "web/External.mako" )
if dn and user == "anonymous":
upc = UserProfileClient( "Registration" , getRPCClient )
result = upc.retrieveVar( dn )
if result[ "OK" ]:
c.sent = result[ "Value" ]
return render( "/reg_done.mako" )
else:
return render("/reg_form.mako")
if not dn or dn == "":
return render("/reg_info.mako")
if "site" not in request.params:
c.select = gConfig.getValue( "/Website/DefaultExternalURL", "http://diracgrid.org" )
return render( "web/External.mako" )
# No idea what this code should do...
if request.params.has_key( "site" ) and len( request.params[ "site" ] ) > 0:
if str( request.params[ "site" ] ) != "All":
c.select = str( request.params[ "site" ] )
gLogger.debug("Request's body:")
for key in request.params.keys():
if not key == "site" and len(request.params[key]) > 0:
c.select = c.select + "&" + key + "=" + request.params[key]
try:
gLogger.debug("%s - %s" % (key,request.params[key]))
except Exception,x:
gLogger.error("Exception: %s" % str(x))
pass
def __deleteHistory(self, name, state):
"""
Deleting item from Load and Save history list
Return resulting list
"name" is a string
"state" can be either "Save" or "Load"
"""
gLogger.info("Running deleteHistory( %s )" % name)
msg = "deleteHistory() for %s@%s" % (getUsername(), getSelectedGroup())
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions(opt, 5)
upc = UserProfileClient("Default", getRPCClient)
group = str(getSelectedGroup())
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar(profile_name)
gLogger.info(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
gLogger.info("Result %s: %s" % (msg, result["Message"]))
return S_OK(list()) # Nothing to delete, return an empty list
else:
result = result["Value"]
if not isinstance(result, list):
err = "List expected at: %s" % profile_name
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
history = list()
for i in result:
if i.has_key("name") and not i["name"] == name:
history.append(i)
if (len(history) > history_length):
history = result[history_length]
gLogger.error("History: %s" % history)
result = upc.storeVar(profile_name, history)
gLogger.info(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
gLogger.info("Result %s: %s" % (msg, history))
return S_OK(history)
def __deleteHistory( self , name , state ):
"""
Deleting item from Load and Save history list
Return resulting list
"name" is a string
"state" can be either "Save" or "Load"
"""
gLogger.info( "Running deleteHistory( %s )" % name )
msg = "deleteHistory() for %s@%s" % ( getUsername() , getSelectedGroup() )
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions( opt , 5 )
upc = UserProfileClient( "Default" , getRPCClient )
group = str( getSelectedGroup() )
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar( profile_name )
gLogger.info( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_OK( list() ) # Nothing to delete, return an empty list
else:
result = result[ "Value" ]
if not isinstance( result , list ):
err = "List expected at: %s" % profile_name
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
history = list()
for i in result:
if i.has_key( "name" ) and not i["name"] == name:
history.append( i )
if( len( history ) > history_length ):
history = result[ history_length ]
gLogger.error( "History: %s" % history )
result = upc.storeVar( profile_name , history )
gLogger.info( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , history ) )
return S_OK( history )
def __getLayout(self):
gLogger.info("Running getLayout()")
msg = "getLayout() for %s@%s" % (getUsername(), getSelectedGroup())
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.listAvailableVars()
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
result = result["Value"]
gLogger.always("array2obj")
availble = map(self.__array2obj, result)
gLogger.always(availble)
users = list()
for i in result:
if len(i) > 1:
users.append({"user": i[0]})
users = uniqueElements(users)
gLogger.info("Result %s: %s AND %s" % (msg, availble, users))
return {"success": "true", "result": availble, "users": users}
def __getLayout( self ) :
gLogger.info( "Running getLayout()" )
msg = "getLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.listAvailableVars()
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
result = result[ "Value" ]
gLogger.always( "array2obj" )
availble = map( self.__array2obj , result )
gLogger.always( availble )
users = list()
for i in result :
if len( i ) > 1 :
users.append( { "user" : i[ 0 ] } )
users = uniqueElements( users )
gLogger.info( "Result %s: %s AND %s" % ( msg , availble , users ) )
return { "success" : "true" , "result" : availble , "users" : users }
def layoutUser(self):
upProfileName = "Summary"
upc = UserProfileClient( "Summary", getRPCClient )
result = upc.listAvailableVars()
if result["OK"]:
result = result["Value"]
userList = []
for i in result:
userList.append(i[0])
userList = uniqueElements(userList)
resultList = []
for j in userList:
resultList.append({'name':j})
total = len(resultList)
resultList.sort()
resultList.insert(0,{'name':'All'})
c.result = {"success":"true","result":resultList,"total":total}
else:
c.result = {"success":"false","error":result["Message"]}
return c.result
def __delBookmarks(self, name):
if name == "columns" or name == "refresh" or name == "defaultLayout" or name == "layouts":
return {
"success":
"false",
"error":
"The name \"" + name +
"\" is reserved, please choose another name. Operation failed"
}
upc = UserProfileClient("Summary", getRPCClient)
result = upc.retrieveVar("Bookmarks")
if result["OK"]:
data = result["Value"]
else:
data = {}
gLogger.info("\033[0;31m data: \033[0m", data)
if data.has_key("layouts"):
if name in data["layouts"]:
del data["layouts"][name]
else:
return {
"success": "false",
"error":
"Can't delete not existing layout: \"" + name + "\""
}
else:
return {
"success": "false",
"error": "Can't read existing layouts, operation failed"
}
if len(data["layouts"]) > 0:
data["defaultLayout"] = data["layouts"].keys()[0]
else:
data["defaultLayout"] = ""
gLogger.info("\033[0;31m data: \033[0m", data)
result = upc.storeVar("Bookmarks", data)
gLogger.info("\033[0;31m result: \033[0m", result)
if result["OK"]:
return self.__getBookmarks()
else:
return {"success": "false", "error": result["Message"]}
def __setHistory( self , item , state ):
"""
Insert item to Load or Save history list in first position and checking for
duplications.
Return resulting list
"item" is a dict
"state" should be either "Save" or "Load" but can be any other value
"""
gLogger.info( "Running setHistory( %s , %s )" % ( item , state ) )
msg = "setHistory() for %s@%s" % ( getUsername() , getSelectedGroup() )
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions( opt , 5 )
upc = UserProfileClient( "Default" , getRPCClient )
group = str( getSelectedGroup() )
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar( profile_name )
gLogger.info( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
history = list()
else:
history = result[ "Value" ]
if not isinstance( history , list ):
err = "List expected at: %s" % profile_name
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
if( len( history ) > history_length ):
history = result[ history_length ]
history.insert( 0 , item )
history = uniqueElements( history )
gLogger.error( "History: %s" % history )
result = upc.storeVar( profile_name , history )
gLogger.info( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , history ) )
return S_OK( history )
def __setHistory(self, item, state):
"""
Insert item to Load or Save history list in first position and checking for
duplications.
Return resulting list
"item" is a dict
"state" should be either "Save" or "Load" but can be any other value
"""
gLogger.info("Running setHistory( %s , %s )" % (item, state))
msg = "setHistory() for %s@%s" % (getUsername(), getSelectedGroup())
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions(opt, 5)
upc = UserProfileClient("Default", getRPCClient)
group = str(getSelectedGroup())
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar(profile_name)
gLogger.info(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
history = list()
else:
history = result["Value"]
if not isinstance(history, list):
err = "List expected at: %s" % profile_name
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
if (len(history) > history_length):
history = result[history_length]
history.insert(0, item)
history = uniqueElements(history)
gLogger.error("History: %s" % history)
result = upc.storeVar(profile_name, history)
gLogger.info(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
gLogger.info("Result %s: %s" % (msg, history))
return S_OK(history)
def web_listAppState(self):
self.__tc.setSetup(False)
try:
app = self.request.arguments['app'][-1]
except KeyError as excp:
raise WErr(400, "Missing %s" % excp)
up = UserProfileClient("Web/App/%s" % app)
result = yield self.threadTask(up.listAvailableVars,
{'UserName': [self.getUserName()]})
if not result['OK']:
raise WErr.fromSERROR(result)
data = result['Value']
self.finish({'app': [e[-1] for e in data]})
def __setData(self,name=False):
gLogger.info("__setData(%s) function" % name)
if not name:
return {"success":"false","error":"Name of the layout is absent"}
data = {}
for i in request.params:
try:
if len(request.params[i]) > 0:
data[i] = str(request.params[i])
except:
pass
gLogger.info("Data to save: %s" % data)
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
gLogger.info("upc.storeVar(%s,%s)" % (name,data))
result = upc.storeVar(name,data)
gLogger.debug(result)
if not result["OK"]:
return {"success":"false","error":result["Message"]}
result = self.__setHistory(name)
if not result["OK"]:
gLogger.error(result["Message"])
return self.__getData()
def __addBookmark(self, path, title):
"""adds a bookmark"""
self.getWidget().waitCursor()
upc = UserProfileClient("Bookkeeping", RPCClient)
result = upc.retrieveVar("Bookmarks")
if result["OK"]:
data = result["Value"]
else:
data = {}
if title in data:
QMessageBox.critical(
self.getWidget(), "Error", "The bookmark with the title \"" +
title + "\" is already exists", QMessageBox.Ok)
return S_ERROR("The bookmark with the title \"" + title +
"\" is already exists")
else:
data[title] = path
result = upc.storeVar("Bookmarks", data)
self.getWidget().arrowCursor()
if result["OK"]:
return self.__getBookmarks()
else:
return S_ERROR(result["Message"])
def __delBookmark(self, title):
"""deletes a bookmark"""
self.getWidget().waitCursor()
upc = UserProfileClient("Bookkeeping", RPCClient)
result = upc.retrieveVar("Bookmarks")
if result["OK"]:
data = result["Value"]
else:
data = {}
if title in data:
del data[title]
else:
QMessageBox.critical(
self.getWidget(), "Error",
"Can't delete not existing bookmark: \"" + title + "\"",
QMessageBox.Ok)
return S_ERROR("Can't delete not existing bookmark: \"" + title +
"\"")
result = upc.storeVar("Bookmarks", data)
self.getWidget().arrowCursor()
if result["OK"]:
return self.__getBookmarks()
else:
return S_ERROR(result["Message"])
def web_saveAppState(self):
self.__tc.setSetup(False)
try:
app = self.request.arguments['app'][-1]
name = self.request.arguments['name'][-1]
state = self.request.arguments['state'][-1]
except KeyError as excp:
raise WErr(400, "Missing %s" % excp)
data = base64.b64encode(zlib.compress(DEncode.encode(state), 9))
up = UserProfileClient("Web/App/%s" % app)
result = yield self.threadTask(up.storeVar, name, data)
if not result['OK']:
raise WErr.fromSERROR(result)
self.set_status(200)
self.finish()
def web_loadAppState(self):
self.__tc.setSetup(False)
try:
app = self.request.arguments['app'][-1]
name = self.request.arguments['name'][-1]
except KeyError as excp:
raise WErr(400, "Missing %s" % excp)
up = UserProfileClient("Web/App/%s" % app)
result = yield self.threadTask(up.retrieveVar, name)
if not result['OK']:
raise WErr.fromSERROR(result)
data = result['Value']
data, count = DEncode.decode(zlib.decompress(base64.b64decode(data)))
self.set_header("Content-Type", "application/json")
self.finish(data)
def layoutUser(self):
upProfileName = "Summary"
upc = UserProfileClient("Summary", getRPCClient)
result = upc.listAvailableVars()
if result["OK"]:
result = result["Value"]
userList = []
for i in result:
userList.append(i[0])
userList = uniqueElements(userList)
resultList = []
for j in userList:
resultList.append({'name': j})
total = len(resultList)
resultList.sort()
resultList.insert(0, {'name': 'All'})
c.result = {
"success": "true",
"result": resultList,
"total": total
}
else:
c.result = {"success": "false", "error": result["Message"]}
return c.result
def __deleteLayout(self):
gLogger.info("Running deleteLayout()")
msg = "delLayout() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__params2string(DELETE_LAYOUT_ARGS)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
args = result["Value"]
name = args["name"]
history = dict()
for i in ["Save", "Load"]:
result = self.__deleteHistory(name, i)
if not result["OK"]:
history[i] = result["Message"]
else:
history[i] = result["Value"]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.deleteVar(name)
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
gLogger.info("Result %s: %s AND %s" % (msg, "true", history))
return {"success": "true", "result": "true", "history": history}
def web_makePublicDesktopState(self):
up = UserProfileClient("Web/application/desktop")
try:
name = self.request.arguments['name'][-1]
except KeyError as excp:
raise WErr(400, "Missing %s" % excp)
try:
access = self.request.arguments['access'][-1].upper()
except KeyError as excp:
access = 'ALL'
if access not in ('ALL', 'VO', 'GROUP', 'USER'):
raise WErr(400, "Invalid access")
# TODO: Check access is in either 'ALL', 'VO' or 'GROUP'
result = yield self.threadTask(up.setVarPermissions, name,
{'ReadAccess': access})
if not result['OK']:
raise WErr.fromSERROR(result)
self.set_status(200)
self.finish()
