private Entity LoadEntityByNameParts(EntityType entityType, string[] nameParts)
{
var sql = @"spFindEntity_byName";
var npdt = new DataTable();
npdt.Columns.Add("ID", typeof(int));
npdt.Columns.Add("Name", typeof(string));
for (int i = 0; i < nameParts.Length; i++)
{
npdt.Rows.Add(i, nameParts[i]);
}
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@UserGuid", SqlDbType.UniqueIdentifier).Value = Context.UserGuid;
cmd.Parameters.Add("@EntityType", SqlDbType.Int).Value = entityType == EntityType.Unknown ? (object)DBNull.Value : entityType;
cmd.Parameters.Add("@NameParts", SqlDbType.Structured).Value = npdt;
using (var dr = cmd.ExecuteReader())
{
dr.Read();
var e = new Entity(Context);
e.LoadFromDataReader(dr);
return(LoadStronglyTypedEntity(e.EntityType, e.Guid));
}
}
}
private void ReleaseLockRecursively(bool forceRelease)
{
LoadAllChildren(false);
foreach (Entity e in EnumerateAllChildren())
{
e.ReleaseLockRecursively(forceRelease);
}
if (!forceRelease)
{
CheckConcurrency();
}
string sql = "spReleaseEntityLock";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@LockOwner", SqlDbType.UniqueIdentifier).Value = Context.ContextGuid;
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Direction = ParameterDirection.Output;
cmd.Parameters.Add("RETVAL", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
cmd.ExecuteNonQuery();
int retval = (int)cmd.Parameters["RETVAL"].Value;
this.lockOwner = Guid.Empty;
this.concurrencyVersion = BitConverter.ToInt64((byte[])cmd.Parameters["@ConcurrencyVersion"].Value, 0);
}
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.ReleaseLock", this.guid));
}
public IEnumerable <Entity> SelectChildren(int from, int max)
{
string sql = "spFindJobInstance_byDetails";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendCommandParameters(cmd, from, max);
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
Entity item = new Entity(Context);
item.LoadFromDataReader(dr);
string classname = "Jhu.Graywulf.Registry." + item.EntityType.ToString();
Type classtype = global::System.Reflection.Assembly.GetExecutingAssembly().GetType(classname);
item = (Entity)classtype.GetConstructor(new Type[] { typeof(Context) }).Invoke(new object[] { Context });
item.LoadFromDataReader(dr);
yield return(item);
}
dr.Close();
}
}
}
private void DeleteRecursively(bool forceOverwrite)
{
LoadAllChildren(true);
// Delete should go in reverse order in order to prevent
// concurrency version exceptions
foreach (Entity e in EnumerateAllChildren().Reverse <Entity>())
{
e.DeleteRecursively(forceOverwrite);
}
if (!forceOverwrite)
{
CheckConcurrency();
}
string sql = "spDeleteEntity";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
this.concurrencyVersion = BitConverter.ToInt64((byte[])cmd.Parameters["@ConcurrencyVersion"].Value, 0);
this.deleted = true;
this.dateDeleted = DateTime.Now;
this.userGuidDeleted = Context.UserGuid;
}
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.Delete", this.guid));
}
/// <summary>
/// Moves the entity up among its siblings.
/// </summary>
/// <remarks>
/// Moves the entity up among its siblings by decreasing its <see cref="Number" /> property.
/// All siblings are reorganized to keep the values of <b>Numbers</b> contigous.
/// </remarks>
public void Move(EntityMoveDirection direction)
{
string sql;
if (direction == EntityMoveDirection.Up)
{
sql = "spMoveUpEntity";
}
else
{
sql = "spMoveDownEntity";
}
CheckConcurrency();
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("RETVAL", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
cmd.ExecuteNonQuery();
var retval = (int)cmd.Parameters["RETVAL"].Value;
if (retval >= 0)
{
this.number = retval;
}
}
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.Move", this.guid));
}
/// <summary>
/// Check whether the entity was modified in the database since it was loaded.
/// </summary>
/// <remarks>
/// Refer to the Developer's Guide about the optimistic concurrency model.
/// The <see cref="Context" /> property must have a value of a valid object context with open database connection.
/// </remarks>
/// <exception cref="InvalidConcurrencyVersionException">Thrown when a potential concurrency issue is detected.</exception>
/// <exception cref="LockingCollisionException">TODO</exception>
protected void CheckConcurrency()
{
// TODO: implement locking for move operations (don't allow move if any locked)
string sql = "spCheckEntityConcurrency";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@LockOwner", SqlDbType.UniqueIdentifier).Value = Context.JobGuid;
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Value = BitConverter.GetBytes(this.concurrencyVersion);
cmd.Parameters.Add("RETVAL", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
cmd.ExecuteNonQuery();
int retval = (int)cmd.Parameters["RETVAL"].Value;
if (retval < 0)
{
Jhu.Graywulf.Logging.Event e = new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.CheckConcurrency", this.guid);;
switch (retval)
{
case -1:
e.Message = LogMessages.InvalidConcurrencyVersion;
Context.LogEvent(e);
throw new InvalidConcurrencyVersionException();
case -2:
e.Message = LogMessages.LockingCollision;
Context.LogEvent(e);
throw new LockingCollisionException();
}
}
}
}
/// <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);
}
}
private void LoadEntityReferences()
{
if (Guid != Guid.Empty && EntityType != EntityType.Unknown && entityReferences.Count > 0)
{
var sql = "spFindEntityReference";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
using (var dr = cmd.ExecuteReader())
{
while (dr.Read())
{
var type = dr.GetByte(1);
var guid = dr.GetGuid(2);
entityReferences[type].ReferencedEntityGuid = guid;
}
}
}
isEntityReferencesLoaded = true;
}
}
public IEnumerable <JobInstance> FindJobInstances(Guid userGuid, Guid queueInstanceGuid, HashSet <Guid> jobDefinitionGuids, JobExecutionState jobExecutionStatus)
{
string sql = "spFindJobInstance_byDetails";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@UserGuid", SqlDbType.UniqueIdentifier).Value = Context.UserGuid;
cmd.Parameters.Add("@ShowHidden", SqlDbType.Bit).Value = Context.ShowHidden;
cmd.Parameters.Add("@ShowDeleted", SqlDbType.Bit).Value = Context.ShowDeleted;
cmd.Parameters.Add("@From", SqlDbType.Int).Value = DBNull.Value;
cmd.Parameters.Add("@Max", SqlDbType.Int).Value = DBNull.Value;
cmd.Parameters.Add("@RowCount", SqlDbType.Int).Direction = ParameterDirection.Output;
cmd.Parameters.Add("@JobUserGuid", SqlDbType.UniqueIdentifier).Value = userGuid == Guid.Empty ? DBNull.Value : (object)userGuid;
cmd.Parameters.Add("@QueueInstanceGuid", SqlDbType.UniqueIdentifier).Value = queueInstanceGuid == Guid.Empty ? DBNull.Value : (object)queueInstanceGuid;
cmd.Parameters.Add("@JobDefinitionGuids", SqlDbType.Structured).Value = CreateGuidListTable(jobDefinitionGuids);
cmd.Parameters.Add("@JobExecutionStatus", SqlDbType.Int).Value = jobExecutionStatus;
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
JobInstance item = new JobInstance(Context);
item.LoadFromDataReader(dr);
yield return(item);
}
dr.Close();
}
}
}
/// <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);
}
public int CountChildren()
{
string sql = "spFindJobInstance_byDetails";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendCommandParameters(cmd, -1, -1);
cmd.ExecuteNonQuery();
return((int)cmd.Parameters["@RowCount"].Value);
}
}
public void Hide()
{
string sql = "spHideEntity";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
this.concurrencyVersion = BitConverter.ToInt64((byte[])cmd.Parameters["@ConcurrencyVersion"].Value, 0);
this.hidden = true;
}
}
public bool CheckEmailDuplicate(Domain domain, string email)
{
var sql = @"spCheckUserEmailDuplicate";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@ParentGuid", SqlDbType.UniqueIdentifier).Value = domain.Guid;
cmd.Parameters.Add("@Email", SqlDbType.NVarChar, 128).Value = email;
cmd.Parameters.Add("RETVAL", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
cmd.ExecuteNonQuery();
return((int)cmd.Parameters["RETVAL"].Value > 0);
}
}
public bool CheckEntityDuplicate(EntityType entityType, Guid entityGuid, Guid parentEntityGuid, string name)
{
var sql = @"spCheckEntityDuplicate";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@UserGuid", SqlDbType.UniqueIdentifier).Value = Context.UserGuid;
cmd.Parameters.Add("@EntityType", SqlDbType.Int).Value = entityType;
cmd.Parameters.Add("@Guid", SqlDbType.UniqueIdentifier).Value = entityGuid == Guid.Empty ? (object)DBNull.Value : entityGuid;
cmd.Parameters.Add("@ParentGuid", SqlDbType.UniqueIdentifier).Value = parentEntityGuid;
cmd.Parameters.Add("@Name", SqlDbType.NVarChar, 128).Value = name;
cmd.Parameters.Add("RETVAL", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
cmd.ExecuteNonQuery();
return((int)cmd.Parameters["RETVAL"].Value > 0);
}
}
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);
}
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);
}
/// <summary>
/// Saves the newly created entity to the database.
/// </summary>
/// <remarks>
/// This function is called by the <see cref="Save()"/> function of the <see cref="Entity" /> class
/// through the <see cref="Create"/> function in the derived classes.
/// The <see cref="Context" /> property must have a value of a valid object context with open database connection.
/// </remarks>
protected virtual void Create()
{
// Generate a new Guid for the entity
guid = Guid.NewGuid();
// --- Create record in the Entities table ---
string sql = "spCreateEntity";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Direction = ParameterDirection.Output;
cmd.Parameters.Add("@ParentGuid", SqlDbType.UniqueIdentifier).Value = parentReference.Guid;
cmd.Parameters.Add("@EntityType", SqlDbType.Int).Value = (int)EntityType; // always use property
cmd.Parameters.Add("@Number", SqlDbType.Int).Direction = ParameterDirection.Output;
AppendEntityCreateModifyParameters(cmd);
cmd.ExecuteNonQuery();
// Read return values
this.concurrencyVersion = BitConverter.ToInt64((byte[])cmd.Parameters["@ConcurrencyVersion"].Value, 0);
this.number = (int)cmd.Parameters["@Number"].Value;
}
using (var cmd = DBHelpers[this.GetType()].CreateInsertCommand(this))
{
AppendBasicParameters(cmd);
cmd.ExecuteNonQuery();
}
isExisting = true;
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.Create", this.guid));
}
/// <summary>
/// Modifies the already existing entity in the database.
/// </summary>
/// <remarks>
/// The <see cref="Context" /> property must have a value of a valid object context with open database connection.
/// </remarks>
/// <param name="forceOverwrite">Determines if concurrency issues are ignored.</param>
/// <exception cref="InvalidConcurrencyVersionException">
/// Thrown when someone else modified the entity since it was loaded from the database.
/// </exception>
protected virtual void Modify(bool forceOverwrite)
{
if (!forceOverwrite)
{
CheckConcurrency();
}
// --- Modify record in the Entities table ---
this.dateModified = DateTime.Now;
string sql = "spModifyEntity";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
AppendBasicParameters(cmd);
cmd.Parameters.Add("@ConcurrencyVersion", SqlDbType.Binary, 8).Direction = ParameterDirection.Output;
AppendEntityCreateModifyParameters(cmd);
cmd.ExecuteNonQuery();
this.concurrencyVersion = BitConverter.ToInt64((byte[])cmd.Parameters["@ConcurrencyVersion"].Value, 0);
}
// --- Modify record in the type specific table
if (DBHelpers[this.GetType()].HasColumns)
{
using (var cmd = DBHelpers[this.GetType()].CreateUpdateCommand(this))
{
AppendBasicParameters(cmd);
cmd.ExecuteNonQuery();
}
}
Context.LogEvent(new Jhu.Graywulf.Logging.Event("Jhu.Graywulf.Registry.Entity.Modify", this.guid));
}
public IEnumerable <Entity> FindReferencing(Entity e)
{
var sql = @"spFindReferencingEntity";
using (var cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@UserGuid", SqlDbType.UniqueIdentifier).Value = Context.UserGuid;
cmd.Parameters.Add("@ShowHidden", SqlDbType.Bit).Value = Context.ShowHidden;
cmd.Parameters.Add("@ShowDeleted", SqlDbType.Bit).Value = Context.ShowDeleted;
cmd.Parameters.Add("@Guid", SqlDbType.UniqueIdentifier).Value = e.Guid;
using (var dr = cmd.ExecuteReader())
{
while (dr.Read())
{
Entity item = new Entity();
item.Context = Context;
item.LoadFromDataReader(dr);
yield return(item);
}
dr.Close();
}
}
}
/// <summary>
/// Gets the next available job from the queue.
/// </summary>
/// <returns>The next available job or null if there are no queued jobs.</returns>
public JobInstance GetNextJobInstance()
{
string sql = "spFindJobInstance_Next";
using (SqlCommand cmd = Context.CreateStoredProcedureCommand(sql))
{
cmd.Parameters.Add("@UserGuid", SqlDbType.UniqueIdentifier).Value = Context.UserGuid;
cmd.Parameters.Add("@QueueInstanceGuid", SqlDbType.UniqueIdentifier).Value = this.Guid;
cmd.Parameters.Add("@JobInstanceGuid", SqlDbType.UniqueIdentifier).Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
if (cmd.Parameters["@JobInstanceGuid"].Value != DBNull.Value)
{
JobInstance j = new JobInstance(Context);
j.Guid = (Guid)cmd.Parameters["@JobInstanceGuid"].Value;
j.Load();
return(j);
}
}
return(null);
}
