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); }