protected void PasswordValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
// Attempt to log in with supplied credentials
try
{
var cluster = new Registry.Cluster(RegistryContext);
cluster.Guid = new Guid(ClusterList.SelectedValue);
cluster.Load();
cluster.LoadDomains(false);
var domain = cluster.Domains[Registry.Constants.SharedDomainName];
var uu = new UserFactory(RegistryContext);
user = uu.LoginUser(domain, Username.Text, Password.Text);
RegistryContext.UserGuid = user.Guid;
RegistryContext.UserName = user.Name;
args.IsValid = true;
}
catch (EntityNotFoundException)
{
args.IsValid = false;
}
}
/// <summary>
/// Find user by activation code
/// </summary>
/// <param name="code"></param>
private User FindUserByActivationCodeInternal(Entity parent, string code)
{
if (code != null && code != String.Empty)
{
var user = new User(Context);
var sql = "spFindUser_byDomainActivationCode";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@DomainGuid", SqlDbType.UniqueIdentifier).Value = parent.Guid;
cmd.Parameters.Add("@ActivationCode", SqlDbType.NVarChar, 50).Value = code;
using (var dr = cmd.ExecuteReader())
{
dr.Read();
user.LoadFromDataReader(dr);
dr.Close();
}
}
return user;
}
else
{
return null;
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Create user object and load data if required
if (RegistryUser != null)
{
user = RegistryUser;
}
else if (TemporaryPrincipal != null)
{
// Create a user object based on the temporary user generated
// based on the OpenID etc. used at sing in.
var identity = (GraywulfIdentity)TemporaryPrincipal.Identity;
user = new Registry.User(identity.User);
user.ParentReference.Value = Domain;
user.Context = RegistryContext;
}
else
{
user = new Registry.User(Domain);
}
// Update form
if (!IsPostBack)
{
UpdateForm();
}
}
protected void PasswordValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
// Attempt to log in with supplied credentials
try
{
var cluster = new Registry.Cluster(RegistryContext);
cluster.Guid = new Guid(ClusterList.SelectedValue);
cluster.Load();
cluster.LoadDomains(false);
var domain = cluster.Domains[Registry.Constants.SharedDomainName];
var uu = new UserFactory(RegistryContext);
user = uu.LoginUser(domain, Username.Text, Password.Text);
RegistryContext.UserGuid = user.Guid;
RegistryContext.UserName = user.Name;
args.IsValid = true;
}
catch (EntityNotFoundException)
{
args.IsValid = false;
}
}
public override void DeleteUser(User user)
{
// Delete local shadow
base.DeleteUser(user);
// Delete user from keystone
KeystoneClient.Delete(ConvertUser(user));
}
public override void DeactivateUser(User user)
{
base.DeactivateUser(user);
var keystoneUser = ConvertUser(user);
keystoneUser.Enabled = false;
KeystoneClient.Update(keystoneUser);
}
private bool ActivateUser(string code)
{
try
{
var uu = new UserFactory(RegistryContext);
user = uu.FindUserByActivationCode(Domain, code);
user.ActivationCode = string.Empty;
user.DeploymentState = DeploymentState.Deployed;
user.Save();
return true;
}
catch (EntityNotFoundException)
{
return false;
}
}
private bool ActivateUser(string code)
{
try
{
var uu = new UserFactory(RegistryContext);
user = uu.FindUserByActivationCode(Domain, code);
user.ActivationCode = string.Empty;
user.DeploymentState = DeploymentState.Deployed;
user.Save();
return(true);
}
catch (EntityNotFoundException)
{
return(false);
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Create user object and load data if required
if (RegistryUser != null)
{
user = RegistryUser;
}
else
{
user = new Jhu.Graywulf.Registry.User(Domain);
}
// Update form
if (!IsPostBack)
{
UpdateForm();
}
}
protected void PasswordValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
// Attempt to log in with supplied credentials
try
{
var uu = new UserFactory(RegistryContext);
user = uu.LoginUser(Domain, Username.Text, Password.Text);
RegistryContext.UserGuid = user.Guid;
RegistryContext.UserName = user.Name;
args.IsValid = true;
}
catch (Exception ex)
{
LogError(ex);
args.IsValid = false;
}
}
public void GenerateAdmin(bool system, string username, string email, string password)
{
cluster.LoadDomains(true);
var domain = cluster.Domains[Constants.SharedDomainName];
domain.LoadUserGroups(true);
var ug = domain.UserGroups[Constants.ClusterAdministratorUserGroupName];
var u = new User(domain)
{
Name = username,
System = system,
Email = email,
DeploymentState = Registry.DeploymentState.Deployed,
};
u.SetPassword(password);
u.Save();
u.MakeMemberOf(ug.Guid);
}
private User FindUserByEmailInternal(Entity parent, string email)
{
var user = new User(Context);
string sql = "spFindUser_byDomainEmail";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@DomainGuid", SqlDbType.UniqueIdentifier).Value = parent.Guid;
cmd.Parameters.Add("@Email", SqlDbType.NVarChar, 128).Value = email;
using (var dr = cmd.ExecuteReader())
{
dr.Read();
user.LoadFromDataReader(dr);
dr.Close();
}
}
return user;
}
private void LoginUser()
{
// Load user from the registry
var uu = new UserFactory(RegistryContext);
user = uu.LoginUser(Domain, Username.Text, Password.Text);
RegistryContext.UserGuid = user.Guid;
RegistryContext.UserName = user.Name;
// If there's any temporary identifier set, associate
// with the user
if (TemporaryPrincipal != null)
{
var identity = (GraywulfIdentity)TemporaryPrincipal.Identity;
var ui = identity.CreateUserIdentity(user);
ui.Save();
TemporaryPrincipal = null;
}
}
public void ManipulateUserTest()
{
using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.ManualCommit))
{
var ip = new KeystoneIdentityProvider(context.Domain);
PurgeTestEntities(ip.KeystoneClient);
// Create a new user and set password
var user = new User(context.Domain);
user.Name = TestPrefix + "user";
user.Email = "*****@*****.**";
ip.CreateUser(user);
ip.ResetPassword(user, "alma");
user.FirstName = "Modified";
ip.ModifyUser(user);
ip.ChangePassword(user, "alma", "alma2");
Assert.IsTrue(user.DeploymentState == DeploymentState.Undeployed);
// At this point a user should be able to be looked up
// even though they aren't active
//ip.VerifyPassword(TestPrefix + user
ip.ActivateUser(user);
Assert.IsTrue(user.DeploymentState == DeploymentState.Deployed);
ip.DeactivateUser(user);
Assert.IsTrue(user.DeploymentState == DeploymentState.Undeployed);
ip.DeleteUser(user);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (RegistryUser != null)
{
OldPasswordRow.Visible = true;
user = RegistryUser;
}
else
{
OldPasswordRow.Visible = false;
// Load user
try
{
var uu = new UserFactory(RegistryContext);
user = uu.FindUserByActivationCode(Domain, Request.QueryString["code"]);
}
catch (EntityNotFoundException)
{
throw new Registry.SecurityException("Access denied");
}
}
}
public User FindUserByIdentity(Domain domain, string protocol, string authority, string identifier)
{
var user = new User(Context);
var sql = "spFindUser_byIdentity";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@DomainGuid", SqlDbType.UniqueIdentifier).Value = domain.Guid;
cmd.Parameters.Add("@Protocol", SqlDbType.NVarChar, 25).Value = protocol;
cmd.Parameters.Add("@Authority", SqlDbType.NVarChar, 250).Value = authority;
cmd.Parameters.Add("@Identifier", SqlDbType.NVarChar, 250).Value = identifier;
using (var dr = cmd.ExecuteReader())
{
dr.Read();
user.LoadFromDataReader(dr);
dr.Close();
}
}
return user;
}
protected void Page_Load(object sender, EventArgs e)
{
if (RegistryUser != null)
{
OldPasswordRow.Visible = true;
user = RegistryUser;
}
else
{
OldPasswordRow.Visible = false;
// Load user
try
{
var uu = new UserFactory(RegistryContext);
uu.FindUserByActivationCode(Domain, Request.QueryString["code"]);
}
catch (EntityNotFoundException)
{
throw new Registry.SecurityException("Access denied");
}
}
}
protected override void OnCreateUser(User user)
{
// Create user in keystone
var keystoneUser = KeystoneClient.Create(ConvertUser(user));
// Create and associated project (tenant)
var keystoneProject = new Keystone.Project
{
Name = user.Name.ToLowerInvariant(),
DomainID = settings.Domain.ToLowerInvariant(),
};
keystoneProject = KeystoneClient.Create(keystoneProject);
// Create user locally
base.OnCreateUser(user);
// Grant user roles on the project just created. This is necessary to
// gain access to services like swift.
// Project has no equivalent in graywulf (because users are not associated
// with federations but only with domains). Hence, project name is simply
// taken from the username.
foreach (var userRole in user.UserRoleMemberships.Values.Where(r => r.UserRole.Default))
{
var roles = KeystoneClient.FindRoles(settings.Domain, userRole.Name, true, false);
if (roles == null || roles.Length == 0)
{
throw new Exception("No matching role found"); // TODO: ***
}
var role = roles[0];
KeystoneClient.GrantRole(keystoneProject, keystoneUser, role);
}
// Add identity to local principal
var principal = settings.CreateAuthenticatedPrincipal(keystoneUser, true);
AddUserIdentity(user, principal.Identity);
}
/// <summary>
/// Constructor for creating a new entity with object context and parent entity set.
/// </summary>
/// <param name="context">An object context class containing session information.</param>
/// <param name="parent">The parent entity in the entity hierarchy.</param>
public UserDatabaseInstance(User parent)
: base(parent.Context, parent)
{
InitializeMembers();
}
protected void Page_Load(object sender, EventArgs e)
{
// Create user object and load data if required
if (RegistryUser != null)
{
user = RegistryUser;
}
else if (TemporaryPrincipal != null)
{
// Create a user object based on the temporary user generated
// based on the OpenID etc. used at sing in.
var identity = (GraywulfIdentity)TemporaryPrincipal.Identity;
user = new Registry.User(identity.User);
user.ParentReference.Value = Domain;
user.Context = RegistryContext;
}
else
{
user = new Registry.User(Domain);
}
// Update form
if (!IsPostBack)
{
UpdateForm();
}
}
/// <summary>
/// Creates a deep copy of the passed object.
/// </summary>
/// <param name="old">A <b>User</b> object to create the deep copy from.</param>
private void CopyMembers(User old)
{
this.title = old.title;
this.firstName = old.firstName;
this.middleName = old.middleName;
this.lastName = old.lastName;
this.gender = old.gender;
this.nonValidatedEmail = old.nonValidatedEmail;
this.email = old.email;
this.dateOfBirth = old.dateOfBirth;
this.company = old.company;
this.jobTitle = old.jobTitle;
this.address = old.address;
this.address2 = old.address2;
this.state = old.state;
this.stateCode = old.stateCode;
this.city = old.city;
this.country = old.country;
this.countryCode = old.countryCode;
this.zipCode = old.zipCode;
this.workPhone = old.workPhone;
this.homePhone = old.homePhone;
this.cellPhone = old.cellPhone;
this.timeZone = old.timeZone;
this.integrated = old.integrated;
this.ntlmUser = old.ntlmUser;
this.passwordHash = Jhu.Graywulf.Util.DeepCloner.CopyArray(old.passwordHash);
}
private void LoginUser()
{
// Load user from the registry
var uu = new UserFactory(RegistryContext);
user = uu.LoginUser(Domain, Username.Text, Password.Text);
RegistryContext.UserGuid = user.Guid;
RegistryContext.UserName = user.Name;
// If there's any temporary identifier set, associate
// with the user
if (TemporaryPrincipal != null)
{
var identity = (GraywulfIdentity)TemporaryPrincipal.Identity;
var ui = identity.CreateUserIdentity(user);
ui.Save();
TemporaryPrincipal = null;
}
}
public UserDatabaseInstanceInstaller(User user)
: base(user.Context)
{
this.user = user;
}
public void Install(bool system, string clusterName, string username, string email, string password)
{
var cluster = new Cluster(Context)
{
Name = clusterName,
System = system,
};
cluster.Save();
// Create administrator group and user
var ug = new UserGroup(cluster)
{
Name = Constants.ClusterAdministratorUserGroupName,
System = system,
};
ug.Save();
var u = new User(cluster)
{
Name = username,
System = system,
Email = email,
DeploymentState = Registry.DeploymentState.Deployed,
};
u.SetPassword(password);
u.Save();
u.MakeMemberOf(ug.Guid);
// Create machine roles and machines
// -- controller role
var mrcont = new MachineRole(cluster)
{
Name = Constants.ControllerMachineRoleName,
System = system,
MachineRoleType = MachineRoleType.StandAlone,
};
mrcont.Save();
var sv = new ServerVersion(mrcont)
{
Name = Constants.ServerVersionName,
};
sv.Save();
var mcont = new Machine(mrcont)
{
Name = Constants.ControllerMachineName,
};
mcont.Save();
var si = new ServerInstance(mcont)
{
Name = Constants.ServerInstanceName,
ServerVersion = sv,
};
si.Save();
// -- node role
var mrnode = new MachineRole(cluster)
{
Name = Constants.NodeMachineRoleName,
MachineRoleType = MachineRoleType.MirroredSet,
};
mrnode.Save();
sv = new ServerVersion(mrnode)
{
Name = Constants.ServerVersionName,
};
sv.Save();
// -- Create a node
/*
Machine mnode = new Machine(Context, mrnode);
mnode.Name = Constants.NodeMachineName;
mnode.Save();
si = new ServerInstance(Context, mnode);
si.Name = Constants.ServerInstanceName;
si.ServerVersionReference.Value = sv;
si.Save();*/
// Temp database definition
var tempdd = new DatabaseDefinition(cluster)
{
Name = Constants.TempDbName,
System = system,
LayoutType = DatabaseLayoutType.Monolithic,
DatabaseInstanceNamePattern = Constants.TempDbInstanceNamePattern,
DatabaseNamePattern = Constants.TempDbNamePattern,
SliceCount = 1,
PartitionCount = 1,
};
tempdd.Save();
var tempddi = new DatabaseDefinitionInstaller(tempdd);
tempddi.GenerateDefaultChildren(sv, Constants.TempDbName);
// Create cluster level jobs and queues
// -- admin queue definition
QueueDefinition qd = new QueueDefinition(cluster)
{
Name = Constants.MaintenanceQueueDefinitionName,
System = system,
};
qd.Save();
QueueInstance qi = new QueueInstance(mcont)
{
Name = Constants.MaintenanceQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- long queue definition
qd = new QueueDefinition(cluster)
{
Name = Constants.LongQueueDefinitionName
};
qd.Save();
qi = new QueueInstance(mcont)
{
Name = Constants.LongQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- quick queue definition
qd = new QueueDefinition(cluster)
{
Name = Constants.QuickQueueDefinitionName,
};
qd.Save();
qi = new QueueInstance(mcont)
{
Name = Constants.QuickQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- database mirror job
var jd = new JobDefinition(cluster)
{
Name = typeof(Jhu.Graywulf.Jobs.MirrorDatabase.MirrorDatabaseJob).Name,
System = system,
WorkflowTypeName = typeof(Jhu.Graywulf.Jobs.MirrorDatabase.MirrorDatabaseJob).AssemblyQualifiedName,
};
jd.Save();
// -- test job
jd = new JobDefinition(cluster)
{
Name = typeof(Jhu.Graywulf.Jobs.Test.TestJob).Name,
System = system,
WorkflowTypeName = typeof(Jhu.Graywulf.Jobs.Test.TestJob).AssemblyQualifiedName,
};
jd.Save();
}
/// <summary>
/// Authenticate user
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
private User LoginUserInternal(Entity parent, string nameOrEmail, string password)
{
var user = new User(Context);
// Load user from the database
string sql = "spLoginUser";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@ParentGuid", SqlDbType.UniqueIdentifier).Value = parent.Guid;
cmd.Parameters.Add("@NameOrEmail", SqlDbType.NVarChar, 50).Value = nameOrEmail;
using (var dr = cmd.ExecuteReader())
{
if (!dr.Read())
{
throw new EntityNotFoundException(ExceptionMessages.LoginFailed);
}
user.LoadFromDataReader(dr);
}
}
// Compute password hash
bool hashok = true;
byte[] hash = User.ComputePasswordHash(password);
// Compare the hash with the one in the database
if (hash.Length != user.PasswordHash.Length)
{
hashok = false;
}
else
{
for (int i = 0; i < hash.Length; i++)
{
if (hash[i] != user.PasswordHash[i])
{
hashok = false;
break;
}
}
}
if (!hashok)
{
throw new SecurityException(ExceptionMessages.LoginFailed);
}
// Update context
Context.UserGuid = user.Guid;
Context.UserName = user.Name;
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.UserFactory.LoginUser", user.Guid));
return user;
}
/// <summary>
/// Constructor for creating a new entity with object context and parent entity set.
/// </summary>
/// <param name="context">An object context class containing session information.</param>
/// <param name="parent">The parent entity in the entity hierarchy.</param>
public UserGroupMembership(User parent)
: base(parent.Context, parent)
{
InitializeMembers();
}
/// <summary>
/// Converts a Graywulf user to a matching Keystone user
/// </summary>
/// <param name="graywulfUser"></param>
/// <returns></returns>
private Jhu.Graywulf.Keystone.User ConvertUser(User graywulfUser)
{
var keystoneUser = new Keystone.User()
{
Name = graywulfUser.Name.ToLowerInvariant(),
DomainID = settings.Domain.ToLowerInvariant(),
Description = graywulfUser.Comments,
Email = graywulfUser.Email.ToLowerInvariant(),
Enabled = graywulfUser.DeploymentState == DeploymentState.Deployed,
};
if (graywulfUser.IsExisting)
{
graywulfUser.LoadUserIdentities(false);
var idname = GetIdentityName(graywulfUser);
if (graywulfUser.UserIdentities.ContainsKey(idname))
{
var uid = graywulfUser.UserIdentities[idname];
var idx = uid.Identifier.LastIndexOf("/");
keystoneUser.ID = uid.Identifier.Substring(idx + 1);
}
else
{
// TODO: we might add logic here, to create user in keystone
throw new IdentityProviderException("No matching identity found."); // TODO
}
}
return keystoneUser;
}
/// <summary>
/// Returns a generated name for the UserIdentity entry
/// in the Graywulf registry.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
private string GetIdentityName(User user)
{
return String.Format("{0}_{1}", settings.AuthorityName, user.Name);
}
public override void ChangePassword(User user, string oldPassword, string newPassword)
{
var keystoneUser = ConvertUser(user);
KeystoneClient.ChangePassword(keystoneUser.ID, oldPassword, newPassword);
}
public DatabaseInstance GetUserDatabaseInstance(User user)
{
var ef = new EntityFactory(Context);
var udis = ef.FindConnection<UserDatabaseInstance>(this, user, (int)UserDatabaseInstance.ReferenceType.User);
var udi = udis.FirstOrDefault();
if (udi == null)
{
return null;
}
else
{
return udi.DatabaseInstance;
}
}
/// <summary>
/// Constructor for creating a new entity with object context and parent entity set.
/// </summary>
/// <param name="context">An object context class containing session information.</param>
/// <param name="parent">The parent entity in the entity hierarchy.</param>
public UserIdentity(User parent)
: base(parent.Context, parent)
{
InitializeMembers();
}
/// <summary>
/// Queries the registry for new jobs to schedule
/// </summary>
private void PollNewJobs()
{
List<Job> temp = new List<Job>();
using (Context context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
context.ContextGuid = contextGuid;
foreach (var queue in Cluster.Queues.Values)
{
var qi = new QueueInstance(context);
qi.Guid = queue.Guid;
qi.Load();
var ji = qi.GetNextJobInstance();
if (ji != null)
{
var user = new User(context);
user.Guid = ji.UserGuidOwner;
user.Load();
var job = new Job()
{
Guid = ji.Guid,
JobID = ji.JobID,
UserGuid = user.Guid,
UserName = user.Name,
QueueGuid = ji.ParentReference.Guid,
WorkflowTypeName = ji.WorkflowTypeName,
};
if ((ji.JobExecutionStatus & JobExecutionState.Scheduled) != 0)
{
job.Status = JobStatus.Starting;
ji.JobExecutionStatus = JobExecutionState.Starting;
}
else if ((ji.JobExecutionStatus & JobExecutionState.Persisted) != 0)
{
// Save cancel requested flag here
ji.JobExecutionStatus ^= JobExecutionState.Persisted;
ji.JobExecutionStatus |= JobExecutionState.Starting;
job.Status = JobStatus.Resuming;
}
else
{
throw new NotImplementedException();
}
ji.Save();
lock (queue)
{
queue.Jobs.Add(job.Guid, job);
}
temp.Add(job);
}
}
}
foreach (var job in temp)
{
StartOrResumeJob(job);
}
}
/// <summary>
/// Creates a new registry object based on the identity and the user supplied.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public UserIdentity CreateUserIdentity(User user)
{
return new UserIdentity(user)
{
Name = String.Format("{0}_{1}", AuthorityName, user.Name),
Protocol = Protocol,
Authority = AuthorityUri,
Identifier = Identifier
};
}
protected override void GetInitializedQuery_Graywulf(QueryBase query, string queryString, string outputTable)
{
var federationname = Federation.AppSettings.FederationName;
var ef = new EntityFactory(Context);
var federation = ef.LoadEntity<Federation>(federationname);
var jd = ef.LoadEntity<JobDefinition>(federationname, typeof(SqlQueryJob).Name);
var user = new User(Context);
user.Guid = Context.UserGuid;
user.Load();
// Load settings
// **** TODO: this always takes settings from SqlQueryJob!!
var settings = Jhu.Graywulf.Registry.Util.LoadSettings<Settings>(jd.Settings);
query.ExecutionMode = ExecutionMode.Graywulf;
query.FederationReference.Name = federationname;
query.QueryString = queryString;
query.SourceDatabaseVersionName = settings[Settings.HotDatabaseVersionName];
query.StatDatabaseVersionName = settings[Settings.StatDatabaseVersionName];
query.QueryTimeout = int.Parse(settings[Settings.LongQueryTimeout]);
// Add MyDB as custom source
var mydbds = new GraywulfDataset();
mydbds.Name = settings[Settings.DefaultDatasetName];
mydbds.DefaultSchemaName = settings[Settings.DefaultSchemaName];
mydbds.DatabaseInstance.Value = user.GetUserDatabaseInstance(federation.MyDBDatabaseVersion);
mydbds.CacheSchemaConnectionString();
query.CustomDatasets.Add(mydbds);
query.DefaultDataset = mydbds;
// Set up MYDB for destination
// ****** TODO add output table name to settings */
query.Destination.Table = new Table()
{
Dataset = mydbds,
SchemaName = settings[Settings.DefaultSchemaName],
TableName = String.IsNullOrWhiteSpace(outputTable) ? "outputtable" : outputTable
};
query.Destination.Operation = DestinationTableOperation.Drop | DestinationTableOperation.Create;
// Set up temporary database
var tempds = new GraywulfDataset();
tempds.IsOnLinkedServer = false;
tempds.DatabaseVersion.Value = federation.TempDatabaseVersion;
query.TemporaryDataset = tempds;
query.TemporaryDataset.DefaultSchemaName = settings[Settings.TemporarySchemaName];
// Set up code database
var codeds = new GraywulfDataset();
codeds.Name = "Code"; // *** TODO
codeds.IsOnLinkedServer = false;
codeds.DatabaseVersion.Value = federation.CodeDatabaseVersion;
query.CodeDataset = codeds;
query.CodeDataset.DefaultSchemaName = "dbo"; // *** TODO
}
/// <summary>
/// Copy contructor for doing deep copy of the <b>User</b> objects.
/// </summary>
/// <param name="old">The <b>User</b> to copy from.</param>
public User(User old)
: base(old)
{
CopyMembers(old);
}
