/// <summary> ///Bind the files with id of the external object. /// </summary> /// <param name="relationshipType"></param> /// <param name="externalObjectId"></param> /// <param name="fileIds"></param> public void Bind(string relationshipType, Guid externalObjectId, IEnumerable<Guid> fileIds) { try { using (TransactionScope ts = new TransactionScope()) using (FileManagementDataContext ctx = DataContextFactory.Create<FileManagementDataContext>()) { List<Guid> associatedFileIds = (from f in ctx.FileBindings where f.ApplicationId == applicationContext.ApplicationId && f.RelationshipType == relationshipType && f.ExtenalObjectId == externalObjectId select f.FileId).Distinct().ToList(); foreach (Guid fileId in fileIds) { if (associatedFileIds.Contains(fileId)) continue; ctx.FileBindings.InsertOnSubmit(new FileBinding { ApplicationId = this.applicationContext.ApplicationId, RelationshipType = relationshipType, ExtenalObjectId = externalObjectId, FileId = fileId }); } ctx.SubmitChanges(); ts.Complete(); } } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } }
public void CacheCommittedWithTransactionTest() { string applicationName = "CacheWithinTransactionScopeTest"; string cacheKey = "CacheWithinTransactionScopeTest.CacheKey"; ICache cache = SpringContext.Current.GetObject<ICache>(); using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) using (TransactionScope transactionScope = new TransactionScope()) { // create a new application to database Application application = new Application { ApplicationName = applicationName, LoweredApplicationName = applicationName.ToLowerInvariant(), Description = "" }; ctx.Applications.InsertOnSubmit(application); ctx.SubmitChanges(); // save it into cache for 1 hour cache.Add(cacheKey, application, new TimeSpan(1, 0, 0), CachePriorityTypes.High); // the application should exist in both database and cache in the transaction Assert.AreEqual(1, ctx.Applications.Count(app => app.ApplicationName == applicationName), "The application should exist in database."); Assert.IsNotNull(cache.Get(cacheKey), "The application should exist in cache."); // complete the transaction transactionScope.Complete(); } using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { // the application should exist in both database and cache in the transaction Assert.AreEqual(1, ctx.Applications.Count(app => app.ApplicationName == applicationName), "The application should exist in database."); Assert.IsNotNull(cache.Get(cacheKey), "The application should exist in cache."); // clear testing data. ctx.Applications.Delete(app => app.ApplicationName == applicationName); cache.Remove(cacheKey); } }
/// <summary> /// Create sequence number on specified type for special object id. /// The method generates the sequence number suppressing transaction scope which means the generated sequence number cannot be rollback. /// </summary> /// <param name="objectId">E.g. we want each company in the system owns standalone sequence number generation. That means company A can have a sequence number 999 as company B has it meanwhile.</param> /// <param name="sequenceNoType">Sequence number type that means a company for above example can has multiple sequence number generation path. E.g. company A has a Order sequence number 999 as it has a Product sequence number 999 meanwhile.</param> /// <returns></returns> public long Create(Guid objectId, string sequenceNoType) { lock (syncObj) { try { using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Suppress)) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { SequenceNo sequenceNo = ctx.SequenceNos.Where(s => s.ObjectId.Equals(objectId) && s.Type.Equals(sequenceNoType) && s.ApplicationId == this.authenticationContext.ApplicationId).FirstOrDefault(); if (sequenceNo == null) { sequenceNo = new SequenceNo() { ApplicationId = this.authenticationContext.ApplicationId, ObjectId = objectId, Type = sequenceNoType, Number = 1 }; ctx.SequenceNos.InsertOnSubmit(sequenceNo); } else { sequenceNo.Number++; } ctx.SubmitChanges(); ts.Complete(); return sequenceNo.Number; } } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } } }
/// <summary> /// Save organization business object. /// If organizationObject.Id equals Guid.Empty, it means to save a new organization. /// Otherwise it's updating an existed organization. /// </summary> /// <param name="organizationObject"></param> private void SaveOrganization(OrganizationObject organizationObject) { try { Organization organization = null; using (TransactionScope transactionScope = new TransactionScope()) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { using (ValidationScope validationScope = new ValidationScope(true)) { // check duplicate organization name int existedOrganizationCount = (from org in ctx.Organizations where org.OrganizationName == organizationObject.OrganizationName && org.ApplicationId == this.authenticationContext.ApplicationId && org.OrganizationId != organizationObject.OrganizationId select org).Count(); if (existedOrganizationCount > 0) validationScope.Error(Resources.ExistedOrganizationName, organizationObject.OrganizationName); // check duplicate organization code if (!string.IsNullOrEmpty(organizationObject.OrganizationCode)) { existedOrganizationCount = (from org in ctx.Organizations where org.OrganizationCode == organizationObject.OrganizationCode && org.ApplicationId == this.authenticationContext.ApplicationId && org.OrganizationId != organizationObject.OrganizationId select org).Count(); if (existedOrganizationCount > 0) validationScope.Error(Resources.ExistedOrganizationCode, organizationObject.OrganizationCode); } // validate organization type OrganizationTypeObject organizationTypeObject = this.GetOrganizationType(organizationObject.OrganizationTypeId); if (organizationTypeObject == null) validationScope.Error(Resources.InvalidOrganizationTypeID); // validate organization located area if (organizationObject.Hierarchies != null && organizationObject.Hierarchies.Count > 0) { foreach (string hierarchyType in organizationObject.Hierarchies.Keys) { HierarchyDataObject hierarchyDataObject = hierarchyApi.GetHierarchyData(organizationObject.Hierarchies[hierarchyType]); if (hierarchyDataObject == null || !string.Equals(hierarchyDataObject.HierarchyType, hierarchyType, StringComparison.OrdinalIgnoreCase)) validationScope.Error(Resources.InvalidHierarchyAssociatedWithOrganization, hierarchyType, hierarchyDataObject.HierarchyDataId); } } // check circular reference of parent if (organizationObject.ParentOrganizationId.HasValue) { if (organizationObject.OrganizationId == organizationObject.ParentOrganizationId.Value) validationScope.Error(Resources.InvalidParentOrganizationID); if (organizationObject.OrganizationId != organizationObject.ParentOrganizationId.Value) { List<string> existedOrganizationNames = new List<string>(); HashSet<Guid> existedOrganizationIds = new HashSet<Guid> { organizationObject.OrganizationId }; OrganizationObject parentOrganizationObject = this.GetOrganization(organizationObject.ParentOrganizationId.Value); if (parentOrganizationObject == null) validationScope.Error(Resources.InvalidParentOrganizationID); else { this.VerifyStatusAgainstParentOrganization(parentOrganizationObject, organizationObject.Status, organizationObject.OrganizationName, validationScope); while (parentOrganizationObject != null) { existedOrganizationNames.Add(parentOrganizationObject.OrganizationName); if (existedOrganizationIds.Contains(parentOrganizationObject.OrganizationId)) { validationScope.Error(Resources.ParentOrganizationCircularReference, FormatCircularOrganizationNames(existedOrganizationNames)); break; } existedOrganizationIds.Add(parentOrganizationObject.OrganizationId); if (!parentOrganizationObject.ParentOrganizationId.HasValue) break; parentOrganizationObject = this.GetOrganization(parentOrganizationObject.ParentOrganizationId.Value); } } } } if (organizationObject.OrganizationId == Guid.Empty) { organization = ExtensionObjectFactory.Create<Organization>(organizationObject); organization.OrganizationCode = organizationObject.OrganizationCode; organization.CreatedDate = DateTime.UtcNow; organization.CreatedBy = this.authenticationContext.User.UserId; ctx.Organizations.InsertOnSubmit(organization); } else { organization = ctx.Organizations.FirstOrDefault(org => org.OrganizationId == organizationObject.OrganizationId); if (organization == null) validationScope.Error(Resources.InvalidOrganizationID); organization.ExtensionDataTypeId = organizationObject.ExtensionDataTypeId; if (organization.OrganizationCode != organizationObject.OrganizationCode) validationScope.Error(Resources.CodeCannotUpdate); // update status of all children only when updates status from Enabled to Disabled. if (organizationObject.Status == OrganizationStatus.Disabled && organization.Status == OrganizationStatus.Enabled) UpdateSubOrganizationsStatus(ctx, new[] { organization.OrganizationId }, organizationObject.Status); } } organization.ApplicationId = this.authenticationContext.ApplicationId; organization.OrganizationName = organizationObject.OrganizationName; organization.OrganizationTypeId = organizationObject.OrganizationTypeId; organization.ParentOrganizationId = organizationObject.ParentOrganizationId; organization.Status = organizationObject.Status; organization.Description = organizationObject.Description; organization.LastUpdatedDate = DateTime.UtcNow; organization.LastUpdatedBy = this.authenticationContext.User.UserId; // remove original hierarchies and added new ones if (organizationObject.OrganizationId != Guid.Empty && organization.Hierarchies.Count > 0) ctx.OrganizationsInHierarchies.DeleteAllOnSubmit(organization.Hierarchies); if (organizationObject.Hierarchies != null && organizationObject.Hierarchies.Count > 0) { foreach (string hierarchyType in organizationObject.Hierarchies.Keys) { HierarchyDataObject hierarchyDataObject = hierarchyApi.GetHierarchyData(organizationObject.Hierarchies[hierarchyType]); if (hierarchyDataObject != null) { ctx.OrganizationsInHierarchies.InsertOnSubmit(new OrganizationsInHierarchy { ApplicationId = authenticationContext.ApplicationId, HierarchyType = hierarchyType, HierarchyDataId = organizationObject.Hierarchies[hierarchyType], Organization = organization, }); } } } organization.ParseExtensionPropertiesFrom(organizationObject); ctx.SubmitChanges(); transactionScope.Complete(); organizationObject.OrganizationId = organization.OrganizationId; organizationObject.CreatedBy = organization.CreatedBy; organizationObject.CreatedDate = organization.CreatedDate; organizationObject.LastUpdatedBy = organization.LastUpdatedBy; organizationObject.LastUpdatedDate = organization.LastUpdatedDate; } } catch (ValidationException) { throw; } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } }
/// <summary> /// Save organization business object. /// If organizationObject.Id equals Guid.Empty, it means to save a new organization. /// Otherwise it's updating an existed organization. /// </summary> /// <param name="organizationObject"></param> public void Save(OrganizationObject organizationObject) { Kit.NotNull(organizationObject, "organizationObject"); Kit.NotNull(organizationObject.OrganizationCode, "organizationObject.OrganizationCode"); Kit.NotNull(organizationObject.OrganizationName, "organizationObject.OrganizationName"); if (organizationObject.OrganizationTypeId == Guid.Empty) throw new ArgumentException(Resources.InvalidOrganizationTypeID); if (organizationObject.Status == OrganizationStatus.None) throw new ArgumentException(Resources.OrganizationStatusNotSpecified, "organizationObject.Status"); try { using (TransactionScope transactionScope = new TransactionScope()) { bool isUpdate = organizationObject.OrganizationId != Guid.Empty; this.SaveOrganization(organizationObject); // remove the cache for update if (isUpdate) base.RemoveCache(organizationObject.OrganizationId); transactionScope.Complete(); UpdateTimeZone(organizationObject); } } catch (ValidationException) { throw; } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } }
/// <summary> /// Set permissions on specified user. /// </summary> /// <param name="userId"></param> /// <param name="permissions"></param> public void SetUserPermissions(Guid userId, IEnumerable<string> permissions) { Kit.NotNull(permissions, "permissions"); try { using (TransactionScope ts = new TransactionScope()) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { ctx.Permissions.Delete(p => p.UserId == userId); foreach (string permission in permissions.Distinct()) { ctx.Permissions.InsertOnSubmit(new Permission() { UserId = userId, PermissionKey = permission }); } ctx.SubmitChanges(); base.RemoveCache(userId); ts.Complete(); } } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } }
public void RegisterCallbackToTransactionStatusChangedTest() { object locker = new object(); List<int> newTransactionThreadIds = new List<int>(); List<int> completedTransactionThreadIds = new List<int>(); List<int> rollbackTransactionThreadIds = new List<int>(); TransactionScopeContext.AfterNewTransactionStarted += threadId => { newTransactionThreadIds.Remove(threadId); }; TransactionScopeContext.AfterTransactionCommitted += threadId => { completedTransactionThreadIds.Remove(threadId); }; TransactionScopeContext.AfterTransactionRollback += threadId => { rollbackTransactionThreadIds.Remove(threadId); }; WaitCallback waitTransactionCompleteCallback = state => { Monitor.Enter(locker); try { newTransactionThreadIds.Add(Thread.CurrentThread.ManagedThreadId); using (TransactionScope transactionScope = new TransactionScope()) { completedTransactionThreadIds.Add(Thread.CurrentThread.ManagedThreadId); transactionScope.Complete(); } } finally { Monitor.Exit(locker); } }; WaitCallback waitTransactionRollbackCallback = state => { Monitor.Enter(locker); try { newTransactionThreadIds.Add(Thread.CurrentThread.ManagedThreadId); using (TransactionScope transactionScope = new TransactionScope()) { rollbackTransactionThreadIds.Add(Thread.CurrentThread.ManagedThreadId); // don't commit the transaction } } finally { Monitor.Exit(locker); } }; ThreadPool.QueueUserWorkItem(waitTransactionCompleteCallback); ThreadPool.QueueUserWorkItem(waitTransactionRollbackCallback); Thread.Sleep(500); Monitor.Enter(locker); try { Assert.AreEqual(0, newTransactionThreadIds.Count, "The thread Ids should be removed in the registered callback."); Assert.AreEqual(0, completedTransactionThreadIds.Count, "The thread Ids should be removed in the registered callback."); Assert.AreEqual(0, rollbackTransactionThreadIds.Count, "The thread Ids should be removed in the registered callback."); } finally { Monitor.Exit(locker); } }
/// <summary> /// Update an existed organization type from detail panel. /// The method needs to load an existed entity by specified id and set control values to overwrite its original properties then persist it. /// </summary> /// <param name="entityId"></param> public override void Update(string entityId) { this.ValidateDataInputForm(new Guid(entityId)); using (TransactionScope ts = new TransactionScope()) { UserObject userObject = membershipApi.Get(new Guid(entityId)); userObject.ExtensionDataTypeId = this.ResolveUserExtensionDataTypeId(); if (this.UserExtensionDataForm != null) this.UserExtensionDataForm.SetObjectPropertiesFromControlValues(userObject); this.SetUserPropertiesFromControls(userObject); string password = null; if (this.TextBoxPassword != null) password = this.TextBoxPassword.Text; membershipApi.Save(userObject, password, null); if (this.OrganizationSelector != null) { OrganizationObject organizationObject = organizationApi.GetOrganization(this.OrganizationSelector.SelectedOrganization.OrganizationId); IEnumerable<Guid> roleIds = this.ResolveSelectedRoleCheckBox(organizationObject); roleApi.SetUserToRoles(userObject.UserId, roleIds); } if (this.PermissionTreeView != null) permissionApi.SetUserPermissions(userObject.UserId, @PermissionTreeView.CheckedValues); ts.Complete(); } }
/// <summary> /// Set the user into the roles. /// </summary> /// <param name="userId"></param> /// <param name="roleIds"></param> protected static void SetUserToRoles(Guid userId, IEnumerable<Guid> roleIds) { using (TransactionScope ts = new TransactionScope()) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { ctx.UsersInRoles.Delete(uir => uir.UserId == userId); foreach (Guid roleId in roleIds) ctx.UsersInRoles.InsertOnSubmit(new UsersInRole { UserId = userId, RoleId = roleId }); ctx.SubmitChanges(); ts.Complete(); } }
/// <summary> /// Create a new role from detail panel and return the id. /// The method needs to create a new entity and set control values to its properties then persist it. /// </summary> /// <returns>returns the id of new created role.</returns> public override string Create() { this.ValidateInput(Guid.Empty); RoleObject roleObject = new RoleObject { RoleName = this.TextBoxName.Text, Description = this.TextBoxDescription.Text, Domain = authenticationContext.TempVariables["Domain.Value"] as string, Predefined = false }; using (TransactionScope ts = new TransactionScope()) { roleApi.Save(roleObject); permissionApi.SetRolePermissions(roleObject.RoleId, this.PermissionTreeView.CheckedValues); ts.Complete(); } return roleObject.RoleId.ToString(); }
/// <summary> /// Update an existed organization type from detail panel. /// The method needs to load an existed entity by specified id and set control values to overwrite its original properties then persist it. /// </summary> /// <param name="entityId"></param> public override void Update(string entityId) { Guid roleId = new Guid(entityId); this.ValidateInput(roleId); RoleObject roleObject = new RoleObject { RoleId = roleId }; roleObject.RoleName = this.TextBoxName.Text; roleObject.Description = this.TextBoxDescription.Text; roleObject.Domain = authenticationContext.TempVariables["Domain.Value"] as string; using (TransactionScope ts = new TransactionScope()) { roleApi.Save(roleObject); permissionApi.SetRolePermissions(roleObject.RoleId, this.PermissionTreeView.CheckedValues); ts.Complete(); } }
/// <summary> /// Save organization type object. /// </summary> /// <param name="organizationTypeObject"></param> /// <exception cref="ValidationException">etc organization type name does exist.</exception> public void Save(OrganizationTypeObject organizationTypeObject) { Kit.NotNull(organizationTypeObject, "organizationTypeObject"); Kit.NotNull(organizationTypeObject.Name, "organizationTypeObject.Name"); if (!this.platformConfiguration.Domains.Select(d => d.Value).Contains(organizationTypeObject.Domain)) throw new ArgumentException(string.Format(Resources.InvalidOrganizationTypeDomain, organizationTypeObject.Domain), "organizationTypeObject.Domain"); Kit.NotNull(organizationTypeObject, "organizationTypeObject"); Kit.NotNull(organizationTypeObject.Name, "organizationTypeObject.Name"); if (!this.platformConfiguration.Domains.Select(d => d.Value).Contains(organizationTypeObject.Domain)) throw new ArgumentException(string.Format(Resources.InvalidOrganizationTypeDomain, organizationTypeObject.Domain), "organizationTypeObject.Domain"); try { using (TransactionScope ts = new TransactionScope()) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { OrganizationType organizationType = null; DeleteStatus originalDeleteStatus = DeleteStatus.Deleted; using (ValidationScope validationScope = new ValidationScope(true)) { if (ctx.OrganizationTypes.Where(x => x.Name == organizationTypeObject.Name && x.ApplicationId == this.authenticationContext.ApplicationId && x.OrganizationTypeId != organizationTypeObject.OrganizationTypeId).Count() > 0) { validationScope.Error(Resources.ExistedOrganizationTypeName, organizationTypeObject.Name); } if (organizationTypeObject.OrganizationTypeId == Guid.Empty) { organizationType = new OrganizationType { ApplicationId = this.authenticationContext.ApplicationId }; ctx.OrganizationTypes.InsertOnSubmit(organizationType); } else { organizationType = ctx.OrganizationTypes.FirstOrDefault(orgType => orgType.OrganizationTypeId == organizationTypeObject.OrganizationTypeId); if (organizationType == null) validationScope.Error(Resources.InvalidOrganizationTypeID); originalDeleteStatus = organizationType.DeleteStatus; } } // set organization type properties. organizationType.Domain = organizationTypeObject.Domain; organizationType.Name = organizationTypeObject.Name; organizationType.Description = organizationTypeObject.Description; organizationType.LastUpdatedDate = DateTime.UtcNow; organizationType.Predefined = organizationTypeObject.Predefined; organizationType.DeleteStatus = organizationTypeObject.DeleteStatus; // if disable an existed organization type if (organizationTypeObject.OrganizationTypeId != Guid.Empty && organizationTypeObject.DeleteStatus == DeleteStatus.Deleted && organizationTypeObject.DeleteStatus != originalDeleteStatus) { // remove the cache copy for disabled organizations. IEnumerable<Guid> disabledOrganizationIds = (from org in ctx.Organizations where org.ApplicationId == this.authenticationContext.ApplicationId && org.OrganizationTypeId == organizationTypeObject.OrganizationTypeId && org.Status != OrganizationStatus.Disabled select org.OrganizationId).ToList(); foreach (Guid disabledOrganizationId in disabledOrganizationIds) base.RemoveCache(disabledOrganizationId); // batch disable the organizations by sql command string command = string.Format(CultureInfo.InvariantCulture, "UPDATE {0} SET Status={1} WHERE ApplicationId='{2}' AND OrganizationTypeId='{3}' AND Status<>{1}", ctx.Mapping.GetTable(typeof(Organization)).TableName, (int)OrganizationStatus.Disabled, this.authenticationContext.ApplicationId, organizationTypeObject.OrganizationTypeId); ctx.ExecuteCommand(command); } ctx.SubmitChanges(); ts.Complete(); organizationTypeObject.OrganizationTypeId = organizationType.OrganizationTypeId; organizationTypeObject.LastUpdatedDate = organizationType.LastUpdatedDate; // remove cache. base.RemoveCache(CacheKey4AllOrganizationTypes); } } catch (ValidationException) { throw; } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } }
/// <summary> /// Create sequence numbers on specified type for special object id. /// The method generates the sequence number suppressing transaction scope which means the generated sequence number cannot be rollback. /// </summary> /// <param name="objectId">E.g. we want each company in the system owns standalone sequence number generation. That means company A can have a sequence number 999 as company B has it meanwhile.</param> /// <param name="sequenceNoType">Sequence number type that means a company for above example can has multiple sequence number generation path. E.g. company A has a Order sequence number 999 as it has a Product sequence number 999 meanwhile.</param> /// <param name="sequenceNoCount">Indicates how many sequence number is required.</param> /// <returns></returns> public IEnumerable<long> Create(Guid objectId, string sequenceNoType, ushort sequenceNoCount) { if (sequenceNoCount <= 0) throw new ArgumentException("The argument \"sequenceNoCount\" should be more than zero.", "sequenceNoCount"); lock (syncObj) { try { using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Suppress)) using (MembershipDataContext ctx = DataContextFactory.Create<MembershipDataContext>()) { SequenceNo sequenceNo = ctx.SequenceNos.Where(s => s.ObjectId.Equals(objectId) && s.Type.Equals(sequenceNoType) && s.ApplicationId == this.authenticationContext.ApplicationId).FirstOrDefault(); long startSequenceNo; if (sequenceNo == null) { sequenceNo = new SequenceNo() { ApplicationId = this.authenticationContext.ApplicationId, ObjectId = objectId, Type = sequenceNoType, Number = sequenceNoCount }; startSequenceNo = 1; ctx.SequenceNos.InsertOnSubmit(sequenceNo); } else { startSequenceNo = sequenceNo.Number + 1; sequenceNo.Number += sequenceNoCount; } ctx.SubmitChanges(); ts.Complete(); List<long> sequenceNumbers = new List<long>(); for (long i = startSequenceNo; i < startSequenceNo + sequenceNoCount; i++) sequenceNumbers.Add(i); return sequenceNumbers; } } catch (Exception exp) { Logger.Instance(this).Error(exp); throw; } } }