public override string ResetPassword(string username, string answer)
        {
            if (!EnablePasswordReset)
            {
                throw new NotSupportedException();
            }

            using (var transaction = new TransactionScope(_mConfiguration))
            {
                var  dataStore = new UserDataStore(transaction);
                User user      = dataStore.FindByName(ApplicationName, username);
                if (user == null)
                {
                    throw new UserNotFoundException(username);
                }

                if (RequiresQuestionAndAnswer &&
                    user.ValidatePasswordAnswer(answer, PasswordAttemptWindow, MaxInvalidPasswordAttempts) == false)
                {
                    transaction.Commit();
                    throw new MembershipPasswordException();
                }
                else
                {
                    string newPassword = System.Web.Security.Membership.GeneratePassword(MinRequiredPasswordLength,
                                                                                         MinRequiredNonAlphanumericCharacters);
                    user.ChangePassword(newPassword);
                    transaction.Commit();
                    return(newPassword);
                }
            }
        }
Exemple #2
0
        public override int DeleteInactiveProfiles(ProfileAuthenticationOption authenticationOption,
                                                   DateTime userInactiveSinceDate)
        {
            ProfileType?profileType = null;

            if (authenticationOption == ProfileAuthenticationOption.Anonymous)
            {
                profileType = ProfileType.Anonymous;
            }
            else if (authenticationOption == ProfileAuthenticationOption.Authenticated)
            {
                profileType = ProfileType.Authenticated;
            }

            int profilesDeleted = 0;

            using (var transaction = new TransactionScope(mConfiguration))
            {
                var profileStore = new ProfileUserDataStore(transaction);

                IList <ProfileUser> users = profileStore.FindByFields(ApplicationName, null, userInactiveSinceDate,
                                                                      profileType, PagingInfo.All);

                profilesDeleted = users.Count;

                foreach (ProfileUser user in users)
                {
                    profileStore.Delete(user.Id);
                }

                transaction.Commit();
            }

            return(profilesDeleted);
        }
Exemple #3
0
        public static void test123()
        {
            using (TransactionScope scope = ELDB2.DBFactory.NewTransactionScope(false))
            {
                IRelationAccesser r  = scope.NewRelationAccesser();
                DataTable         tb = r.DoQuery("select * from storages order by Address").Tables[0];

                // =================================
                System.Console.WriteLine(System.DateTime.Now.Second + ":" + System.DateTime.Now.Millisecond);
                ELDB2.HashSelectHandle h = new ELDB2.HashSelectHandle(tb);
                int j = 0;
                for (int k = 0; k < 1000; k++)
                {
                    foreach (DataRow row in tb.Rows)
                    {
                        Hashtable t = h.Select <string>("Address", row.Field <string>("Address").Trim());

                        for (int i = 0; i < t.Count; i++)
                        {
                            j++;
                        }
                    }
                }
                System.Console.WriteLine(j.ToString());
                System.Console.WriteLine(System.DateTime.Now.Second + ":" + System.DateTime.Now.Millisecond);
                // =================================
                scope.Commit();
            }
        }
Exemple #4
0
        /// <summary>
        /// Moves the calendar.
        /// </summary>
        /// <param name="calendar">The calendar.</param>
        /// <param name="newFolder">The new folder.</param>
        public static void MoveCalendar(Calendar calendar, CalendarFolder newFolder)
        {
            if (calendar == null)
            {
                throw new ArgumentNullException("calendar");
            }
            if (newFolder == null)
            {
                throw new ArgumentNullException("newFolder");
            }

            using (TransactionScope tran = DataContext.Current.BeginTransaction())
            {
                // Raise Calendar Moving
                RaiseEvent(CalendarMoving, calendar, EventArgs.Empty);

                calendar.CalendarFolderId = newFolder.PrimaryKeyId.Value;
                calendar.Owner            = newFolder.Owner;

                calendar.Save();

                RaiseEvent(CalendarMoved, calendar, EventArgs.Empty);

                tran.Commit();
            }
        }
Exemple #5
0
        /// <summary>
        /// Creates the folder.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static CalendarFolder CreateFolder(CalendarFolder parent, string name)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }


            using (TransactionScope tran = DataContext.Current.BeginTransaction())
            {
                // Create Detached Folder
                CalendarFolder newRoot = new CalendarFolder();

                newRoot.Title     = name;
                newRoot.ProjectId = parent.ProjectId;
                newRoot.Owner     = parent.Owner;
                newRoot.Save();

                // Append to
                TreeNode node = parent.GetTreeService().AppendChild(newRoot);
                parent.Save();

                tran.Commit();

                return(newRoot);
            }
        }
Exemple #6
0
        public SqliteChatRecordPersister(string sqlitePath)
        {
            try
            {
                bool isNew = !File.Exists(sqlitePath);
                //2014.11.27
                string dirName = Path.GetDirectoryName(sqlitePath);
                if (!Directory.Exists(dirName))
                {
                    Directory.CreateDirectory(dirName);
                }


                //初始化Sqlite数据库
                DataConfiguration       config = new SqliteDataConfiguration(sqlitePath);
                TransactionScopeFactory transactionScopeFactory = new TransactionScopeFactory(config);
                transactionScopeFactory.Initialize();

                if (isNew)
                {
                    string sql = "CREATE TABLE ChatMessageRecord (AutoID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, SpeakerID VARCHAR( 0, 20 ) NOT NULL, AudienceID VARCHAR( 0, 20 ) NOT NULL, IsGroupChat BOOLEAN NOT NULL,IsNotice BOOLEAN NOT NULL, Content BLOB NOT NULL, OccureTime DATETIME NOT NULL ); "
                                 + "CREATE INDEX idx_ChatMessageRecord ON ChatMessageRecord ( SpeakerID, AudienceID, OccureTime DESC );"
                                 + "CREATE INDEX idx2_ChatMessageRecord ON ChatMessageRecord ( AudienceID, IsGroupChat, OccureTime );";
                    using (TransactionScope scope = transactionScopeFactory.NewTransactionScope())
                    {
                        IRelationAccesser accesser = scope.NewRelationAccesser();
                        accesser.DoCommand(sql);
                        scope.Commit();
                    }
                }

                base.Initialize(transactionScopeFactory);
            }
            catch { }
        }
        /// <summary>
        /// Marks orphaned file records (the ones that do not have a referencing binary record anymore) as Deleted.
        /// </summary>
        public void CleanupFilesSetDeleteFlag()
        {
            var isLocalTransaction = false;

            if (!TransactionScope.IsActive)
            {
                TransactionScope.Begin();
                isLocalTransaction = true;
            }

            try
            {
                using (var proc = new SqlProcedure {
                    CommandText = CleanupFileSetIsdeletedScript, CommandType = CommandType.Text
                })
                {
                    proc.CommandType = CommandType.Text;
                    proc.ExecuteNonQuery();
                }

                if (isLocalTransaction && TransactionScope.IsActive)
                {
                    TransactionScope.Commit();
                }
            }
            catch (Exception ex)
            {
                if (isLocalTransaction && TransactionScope.IsActive)
                {
                    TransactionScope.Rollback();
                }

                throw new DataException("Error during setting deleted flag on files.", ex);
            }
        }
Exemple #8
0
        public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
        {
            using (var transaction = new TransactionScope(mConfiguration))
            {
                var usersInRolesStore = new UserInRoleDataStore(transaction);

                foreach (string userName in usernames)
                {
                    foreach (string roleName in roleNames)
                    {
                        var        rDS        = new RoleDataStore(transaction);
                        Role       role       = rDS.FindByName(mApplicationName, roleName);
                        var        uDS        = new UserDataStore(transaction);
                        User       user       = uDS.FindByName(mApplicationName, userName);
                        UserInRole userInRole = usersInRolesStore.Find(ApplicationName, user, role);
                        if (userInRole == null)
                        {
                            throw new UserInRoleNotFoundException(userName, roleName);
                        }

                        userInRole.Deleted = true;
                        usersInRolesStore.Update(userInRole);
                    }
                }

                transaction.Commit();
            }
        }
Exemple #9
0
        public void Invoke(object Sender, object Element)
        {
            if (Element is CommandParameters)
            {
                CommandParameters   cp        = (CommandParameters)Element;
                DateTime            startDate = DateTime.Parse(cp.CommandArguments["primaryKeyId"], CultureInfo.InvariantCulture);
                TimeTrackingBlock[] mas       = TimeTrackingBlock.List(FilterElement.EqualElement("OwnerId", Mediachase.IBN.Business.Security.CurrentUser.UserID), FilterElement.EqualElement("StartDate", startDate));

                using (TransactionScope tran = DataContext.Current.BeginTransaction())
                {
                    foreach (TimeTrackingBlock ttb in mas)
                    {
                        StateMachineService sms = ((BusinessObject)ttb).GetService <StateMachineService>();

                        // process only initial state
                        if (sms.StateMachine.GetStateIndex(sms.CurrentState.Name) == 0)
                        {
                            StateTransition[] availableTransitions = sms.GetNextAvailableTransitions(true);
                            if (availableTransitions.Length > 0)
                            {
                                sms.MakeTransition(availableTransitions[0].Uid);
                                ttb.Save();
                            }
                        }
                    }
                    tran.Commit();
                }

                CHelper.RequireBindGrid();
            }
        }
Exemple #10
0
        /// <summary>
        /// Deletes the navigation item.
        /// </summary>
        /// <param name="fullId">The full id.</param>
        /// <param name="profileId">The profile id.</param>
        /// <param name="principalId">The principal id.</param>
        public static void DeleteNavigationItem(string fullId, PrimaryKeyId?profileId, PrimaryKeyId?principalId)
        {
            FilterElementCollection filters = new FilterElementCollection();

            filters.Add(new FilterElement(CustomizationItemEntity.FieldXmlFullId, FilterElementType.Like, fullId + "%"));
            filters.Add(FilterElement.EqualElement(CustomizationItemEntity.FieldStructureType, (int)CustomizationStructureType.NavigationMenu));
            filters.Add(FilterElement.EqualElement(CustomizationItemEntity.FieldCommandType, (int)ItemCommandType.Add));

            // delete user level only
            if (principalId.HasValue)
            {
                filters.Add(FilterElement.EqualElement(CustomizationItemEntity.FieldPrincipalId, principalId.Value));
            }
            // delete profile and user level
            else if (profileId.HasValue)
            {
                OrBlockFilterElement block = new OrBlockFilterElement();
                block.ChildElements.Add(FilterElement.EqualElement(CustomizationItemEntity.FieldProfileId, profileId.Value));
                block.ChildElements.Add(FilterElement.IsNotNullElement(CustomizationItemEntity.FieldPrincipalId));
                filters.Add(block);
            }
            // else delete all - we don't use filter in that case

            using (TransactionScope transaction = DataContext.Current.BeginTransaction())
            {
                foreach (EntityObject item in BusinessManager.List(CustomizationItemEntity.ClassName, filters.ToArray()))
                {
                    BusinessManager.Delete(item);
                }

                transaction.Commit();
            }

            ClearCache(profileId, principalId);
        }
Exemple #11
0
        public IList <TEntity> Select <TEntity>(string sql, bool isUsedHash) where TEntity : new()
        {
            List <TEntity> list = new List <TEntity>();

            using (TransactionScope scope = ELDB2.DBFactory.NewTransactionScope(false))
            {
                IRelationAccesser r     = scope.NewRelationAccesser();
                DataTable         table = r.DoQuery(sql).Tables[0];
                if (isUsedHash)
                {
                    AddToHash(table);
                }
                foreach (DataRow row  in table.Rows)
                {
                    TEntity entity = new TEntity();
                    foreach (DataColumn col in row.Table.Columns)
                    {
                        ((ELDB2.IHashEntity)entity).PropertySet[col.ColumnName] = row[col.ColumnName];
                    }

                    list.Add(entity);
                }

                scope.Commit();
            }
            return(list);
        }
        public override void CreateRegion(Region region)
        {
            if (region.RegionType == null)
            {
                throw new ArgumentNullException("region", "RegionType is null");
            }
            if (string.IsNullOrEmpty(region.Name))
            {
                throw new ProviderException("Region name cannot be empty or null.");
            }
            if (region.Name.IndexOf(',') > 0)
            {
                throw new ArgumentException("Region names cannot contain commas.", "region");
            }

            using (var transaction = new TransactionScope(_configuration))
            {
                if (!RegionTypeExists(region.RegionType))
                {
                    CreateRegionType(region.RegionType);
                }

                var rDs = new RegionDataStore(transaction);
                rDs.Insert(region);
                transaction.Commit();
            }
        }
        public void Invoke(object Sender, object Element)
        {
            if (Element is CommandParameters)
            {
                CommandParameters cp            = (CommandParameters)Element;
                string[]          elemsToDelete = EntityGrid.GetCheckedCollection(((CommandManager)Sender).Page, cp.CommandArguments["GridId"]);

                int error = 0;
                using (TransactionScope tran = DataContext.Current.BeginTransaction())
                {
                    foreach (string elem in elemsToDelete)
                    {
                        int id = Convert.ToInt32(elem.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries)[0], CultureInfo.InvariantCulture);
                        if (id > 0)
                        {
                            try
                            {
                                ListManager.DeleteList(id);
                            }
                            catch
                            {
                                error++;
                            }
                        }
                    }
                    tran.Commit();
                }
                if (error > 0)
                {
                    ClientScript.RegisterStartupScript(((Control)Sender).Page, ((Control)Sender).Page.GetType(), Guid.NewGuid().ToString("N"),
                                                       String.Format("alert('{0}');", CHelper.GetResFileString("{IbnFramework.ListInfo:RefItemException}")), true);
                }
            }
        }
Exemple #14
0
        public override Message CreateMessage(Topic topic, string idParentMessage, string owner, string title, string body, Attachment.FileInfo attachment)
        {
            //Check attachment
            if (attachment != null)
            {
                Attachment.FileHelper.CheckFile(attachment, topic.Category.AttachExtensions, topic.Category.AttachMaxSize);
            }

            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                TopicDataStore topicStore = new TopicDataStore(transaction);
                topicStore.Attach(topic);

                MessageDataStore messageStore  = new MessageDataStore(transaction);
                Message          parentMessage = messageStore.FindByKey(idParentMessage);
                if (parentMessage == null)
                {
                    throw new MessageNotFoundException(idParentMessage);
                }

                Message newMessage = new Message(topic, idParentMessage, owner, title, body, attachment);

                messageStore.Insert(newMessage);

                transaction.Commit();

                //Notify user for answer
                NotifyUserReply(parentMessage, newMessage);

                return(newMessage);
            }
        }
Exemple #15
0
        /// <summary>
        /// Create the topic and the relative root message.
        /// </summary>
        /// <param name="category"></param>
        /// <param name="owner"></param>
        /// <param name="title"></param>
        /// <param name="body"></param>
        /// <param name="attachment">Use null if you don't have any attachment</param>
        /// <param name="topic">Returns the topic created</param>
        /// <param name="rootMessage">Returns the message created</param>
        public override void CreateTopic(Category category, string owner,
                                         string title, string body, Attachment.FileInfo attachment,
                                         out Topic topic,
                                         out Message rootMessage, string groups)
        {
            //Check attachment
            if (attachment != null)
            {
                Attachment.FileHelper.CheckFile(attachment, category.AttachExtensions, category.AttachMaxSize);
            }

            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                CategoryDataStore forumStore = new CategoryDataStore(transaction);
                forumStore.Attach(category);

                //Insert topic
                TopicDataStore topicStore = new TopicDataStore(transaction);
                topic        = new Topic(category, owner, title);
                topic.Groups = groups;
                topicStore.Insert(topic);

                //Insert root message
                MessageDataStore messageStore = new MessageDataStore(transaction);
                rootMessage = new Message(topic, null, owner, title, body, attachment);

                messageStore.Insert(rootMessage);

                transaction.Commit();
            }
        }
        public override Draft UpsertDraft(Draft draft)
        {
            try
            {
                using (TransactionScope transaction = new TransactionScope(mConfiguration))
                {
                    DraftDataStore dataStore = new DraftDataStore(transaction);

                    IList <Draft> listDrafts = dataStore.FindItemByChapterId(draft.VersionId);
                    if (listDrafts.Count > 0)
                    {
                        string tempContent = draft.Content;
                        draft         = listDrafts.First <Draft>();
                        draft.Content = tempContent;
                        dataStore.Update(draft);
                    }
                    else
                    {
                        dataStore.Insert(draft);
                    }

                    transaction.Commit();

                    return(draft);
                }
            }
            catch (NotImplementedException ex)
            {
                throw ex;
            }
        }
Exemple #17
0
        public override void CreateRole(string roleName)
        {
            //Check required for MSDN
            if (roleName == null || roleName == "")
            {
                throw new ProviderException("Role name cannot be empty or null.");
            }
            if (roleName.IndexOf(',') > 0)
            {
                throw new ArgumentException("Role names cannot contain commas.");
            }
            if (RoleExists(roleName))
            {
                throw new ProviderException("Role name already exists.");
            }

            using (var transaction = new TransactionScope(mConfiguration))
            {
                var roleStore = new RoleDataStore(transaction);

                roleStore.Insert(new Role(ApplicationName, roleName));

                transaction.Commit();
            }
        }
        public override void DeletePerson(string personId)
        {
            // If person regions exist.
            if (IsPersonInPersonRegion(personId))
            {
                throw new SchemaIntegrityException("Unable to delete. Person exists in a Region");
            }

            // If person persontypes exist.
            if (IsPersonInPersonType(personId))
            {
                throw new SchemaIntegrityException("Unable to delete. Person exists in a PersonType");
            }

            // If person personsite exist.
            if (IsPersonInPersonSite(personId))
            {
                throw new SchemaIntegrityException("Unable to delete. Person exists at a Site");
            }

            using (var transaction = new TransactionScope(_configuration))
            {
                var    ptDS   = new PersonDataStore(transaction);
                Person person = ptDS.FindByKey(personId);
                User   user   = MembershipManager.GetUserByPerson(person);
                System.Web.Security.Membership.DeleteUser(user.Name);
                person.Deleted = true;
                ptDS.Update(person);
                transaction.Commit();
            }
        }
        static void TestCreate()
        {
            DataContext.Current = new DataContext("Data source=S2;Initial catalog=ibn48portal;Integrated Security=SSPI;");

            using (TransactionScope tran = DataContext.Current.BeginTransaction())
            {
                WorkflowDefinitionEntity entity1 = new WorkflowDefinitionEntity();
                entity1.Name = "Test 111";
                entity1.SupportedIbnObjectTypes = new int[] { 16 };

                BusinessManager.Create(entity1);

                WorkflowDefinitionEntity entity2 = new WorkflowDefinitionEntity();
                entity2.Name = "Test 222";
                entity2.SupportedIbnObjectTypes = new int[] { 16, 5, 6, 7 };

                BusinessManager.Create(entity2);

                WorkflowDefinitionEntity entity3 = new WorkflowDefinitionEntity();
                entity3.Name = "Test 333";
                entity3.SupportedIbnObjectTypes = new int[] { 5, 6, 7 };

                BusinessManager.Create(entity3);

                tran.Commit();
            }
        }
        public override void CreatePersonSite(string personId, string siteId, bool?isAdministrator, bool?isManager,
                                              bool?isAssigned, bool isDefault)
        {
            // Create a new record in the PersonSite table.
            using (var transaction = new TransactionScope(_configuration))
            {
                var psDS = new PersonSiteDataStore(transaction);
                var ps   = new PersonSite();
                var pDS  = new PersonDataStore(transaction);
                ps.Person = pDS.FindByKey(personId);
                var sDS = new SiteDataStore(transaction);
                ps.Site = sDS.FindByKey(siteId);
                if (isAdministrator != null)
                {
                    ps.IsAdministrator = (bool)isAdministrator;
                }
                if (isManager != null)
                {
                    ps.IsManager = (bool)isManager;
                }
                if (isAssigned != null)
                {
                    ps.IsAssigned = (bool)isAssigned;
                }
                ps.IsDefault = isDefault;
                psDS.Insert(ps);

                transaction.Commit();
            }
        }
Exemple #21
0
        public async Task <IActionResult> DeleteConfirmed(int id, Guid fileId)
        {
            var transactions = new TransactionScope();

            try
            {
                if (!fileId.Equals(Guid.Empty))
                {
                    transactions.Transactions.Add(_filesContext.Database.BeginTransaction());
                    await _fileRepository.ExecuteAsync(
                        new DeleteFileCommand(_filesContext)
                    {
                        Id = fileId
                    });
                }

                transactions.Transactions.Add(_context.Database.BeginTransaction());
                await _postRepository.ExecuteAsync(
                    new DeletePostCommand(_context)
                {
                    Id = id
                });

                transactions.Commit();
            }
            catch (Exception exception)
            {
                transactions.Rollback();
                ExceptionDispatchInfo.Capture(exception.InnerException).Throw();
            }

            return(RedirectToAction("Index"));
        }
        public override void DeleteCategory(Category category)
        {
            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                CategoryDataStore dataStore = new CategoryDataStore(transaction);

                // Delete should only be allowed if the following conditions are true:
                // 1. There are no child categories.
                if (dataStore.FindByChildOfCategory(category.Id).Count > 0)
                {
                    throw new SchemaIntegrityException("Category has child categories");
                }

                // 2. There are no articles associated with this category.
                ArticleDataStore ads = new ArticleDataStore(transaction);
                if (ads.FindByCategory(category).Count > 0)
                {
                    throw new SchemaIntegrityException("Articles are associated with this category");
                }

                // Delete all access items.
                AccessLayer.AccessDataStore accessDs  = new AccessLayer.AccessDataStore(transaction);
                IList <AccessLayer.Access>  allAccess = accessDs.FindAllByItem(category.Id);

                foreach (AccessLayer.Access access in allAccess)
                {
                    access.Deleted = true;
                    accessDs.Update(access);
                }

                category.Deleted = true;
                dataStore.Update(category);
                transaction.Commit();
            }
        }
Exemple #23
0
        public CommandExecutionResult Execute(CommandBase cmd)
        {
            var executionResult = new CommandExecutionResult();

            executionResult.PipelineResults = new List <CommandPipelineResult>();

            // SECURITY
            var securityResult         = cmd.SecurityPolicy.Validate(cmd);
            var securityPipelineResult = new CommandSecurityPolicyPipelineResult(securityResult, cmd.SecurityPolicy);

            executionResult.PipelineResults.Add(securityPipelineResult);

            if (!executionResult.Success)
            {
                return(executionResult);
            }

            // VALIDATORS


            if (!executionResult.Success)
            {
                return(executionResult);
            }

            // PROJECTIONS
            using (var tx = new TransactionScope())
            {
                tx.Commit();
            }

            return(executionResult);
        }
        public override Article CreateArticle(Category category, string owner,
                                              string name, string fileName, string title,
                                              string description, string body, bool isUpload, bool isEnabled, bool isNumbChaps,
                                              bool isAckRequired)
        {
            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                ArticleDataStore articleStore = new ArticleDataStore(transaction);
                if (articleStore.FindByName(name) != null)
                {
                    throw new ArticleNameAlreadyExistsException(name);
                }

                CategoryDataStore dataStore = new CategoryDataStore(transaction);
                dataStore.Attach(category);

                Article article = new Article(category, name, fileName, owner, title, description, body, isUpload, isEnabled, isNumbChaps);
                article.Author = owner;
                //article.Tag = isAckRequired.ToString();
                article.RequiresAck = isAckRequired;

                if (category.AutoApprove)
                {
                    article.Approved = true;
                }

                articleStore.Insert(article);
                transaction.Commit();

                return(article);
            }
        }
Exemple #25
0
        /// <summary>
        /// Deletes the folder.
        /// </summary>
        /// <param name="folder">The folder.</param>
        public static void DeleteFolder(CalendarFolder folder)
        {
            if (folder == null)
            {
                throw new ArgumentNullException("folder");
            }

            using (TransactionScope tran = DataContext.Current.BeginTransaction())
            {
                TreeService treeService = folder.GetTreeService();

                //Erase all child folders
                foreach (TreeNode node in TreeManager.GetAllChildNodes(treeService.CurrentNode))
                {
                    CalendarFolder childFolder = (CalendarFolder)node.InnerObject;
                    EraseFolder(childFolder);
                    treeService.RemoveChild(node.ObjectId);
                    childFolder.Delete();
                }

                //Erase current folder
                EraseFolder(folder);
                folder.Delete();

                tran.Commit();
            }
        }
        /// <summary>
        /// Update the specified article. Increment the version if required.
        /// </summary>
        /// <param name="article"></param>
        /// <param name="backupVersion">If true the previous article version is saved as a backup in the VersionedArticle and the current version is incremented.</param>
        public override void UpdateArticle(Article article, bool backupVersion)
        {
            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                ArticleDataStore dataStore = new ArticleDataStore(transaction);

                VersionedArticle versionedArticle = null;

                if (backupVersion)
                {
                    //Retrive the previous version (before saving the new instance) and save a versioned row

                    Article prevVersion = dataStore.FindByKey(article.Id);
                    if (prevVersion == null)
                    {
                        throw new ArticleNotFoundException(article.Id);
                    }

                    versionedArticle = new VersionedArticle(prevVersion);

                    VersionedArticleDataStore versionedStore = new VersionedArticleDataStore(transaction);
                    versionedStore.Insert(versionedArticle);

                    //Increment the current article version
                    article.IncrementVersion();
                }

                //flag the entity to be updated and attach the entity to the db
                // I must use InsertOrUpdateCopy because if backupVersion = true there is already a
                // persistent entity in the session and I must copy the values to this instance. The Update method in this case throw an exception
                article = dataStore.InsertOrUpdateCopy(article);

                transaction.Commit();
            }
        }
Exemple #27
0
        protected void SaveButton_ServerClick(object sender, EventArgs e)
        {
            int      fid = ListFolderId;
            ListInfo list;

            using (TransactionScope scope = DataContext.Current.BeginTransaction())
            {
                int templateId = int.Parse(ddTemplates.SelectedValue);
                if (templateId > 0)
                {
                    list = ListManager.CreateListFromTemplate(templateId, fid, ListNameTextBox.Text.Trim(), cbWithData.Checked);
                }
                else
                {
                    list = ListManager.CreateList(fid, ListNameTextBox.Text.Trim());
                }

                list.Description = txtDescription.Text;
                list.Properties["ListType"].Value = int.Parse(ddType.SelectedValue);
                list.Properties["Status"].Value   = int.Parse(ddStatus.SelectedValue);
                list.Save();

                scope.Commit();
            }

            MetaClass mc = ListManager.GetListMetaClass(list);

            string url = String.Format(CultureInfo.InvariantCulture,
                                       "{0}?class={1}",
                                       CHelper.ListAdminPage,
                                       mc.Name);

            Response.Redirect(url, true);
        }
        public override ChapterVersion CreateChapterVersion(string docId, ChapterVersion chapterVersion, VersionUpdateType versionUpdateType)
        {
            using (TransactionScope transaction = new TransactionScope(mConfiguration))
            {
                ChapterVersionDataStore dataStore = new ChapterVersionDataStore(transaction);


                int maxSequenceNumber = 0;

                if (versionUpdateType == VersionUpdateType.New)
                {
                    maxSequenceNumber = GetNewSequenceNo(docId); //only generate sequence number when adding a new chapter else use existing sequence number
                }
                else
                {
                    maxSequenceNumber = chapterVersion.Sequence;
                }

                chapterVersion.Version      = GenerateVersionNumber(versionUpdateType, chapterVersion.Version);
                chapterVersion.VersionOrder = GetVersionOrder(docId, chapterVersion.ChapterId);

                //if (!CheckChapterName(docId, chapterVersion.Name))
                // {
                ChapterVersion chapterVer = new ChapterVersion(docId, chapterVersion.ChapterId, chapterVersion.Name, chapterVersion.Content, chapterVersion.Version, chapterVersion.VersionOrder, maxSequenceNumber);

                dataStore.Insert(chapterVer);
                transaction.Commit();

                return(chapterVer);
                //}
                //else
                //  return chapterVersion;
            }
        }
Exemple #29
0
 public static void test124()
 {
     using (TransactionScope scope = ELDB2.DBFactory.NewTransactionScope(false))
     {
         IRelationAccesser r  = scope.NewRelationAccesser();
         DataTable         tb = r.DoQuery("select * from storages order by Address").Tables[0];
         // ========================
         System.Console.WriteLine(System.DateTime.Now.Second + ":" + System.DateTime.Now.Millisecond);
         int j = 0;
         for (int i = 0; i < 1000; i++)
         {
             foreach (DataRow row0 in tb.Rows)
             {
                 DataRow[] rows = tb.Select(string.Format("Address = '{0}'", row0["Address"]));
                 foreach (DataRow row in rows)
                 {
                     j++;
                 }
             }
         }
         System.Console.WriteLine(j.ToString());
         System.Console.WriteLine(System.DateTime.Now.Second + ":" + System.DateTime.Now.Millisecond);
         // =========================
         scope.Commit();
     }
 }
        public override void DeleteChapter(string chapterId)
        {
            try
            {
                using (TransactionScope transaction = new TransactionScope(mConfiguration))
                {
                    ChapterDataStore dataStore = new ChapterDataStore(transaction);
                    dataStore.Delete(chapterId);

                    ChapterVersionDataStore dsChapVersion  = new ChapterVersionDataStore(transaction);
                    IList <ChapterVersion>  chVersionsList = dsChapVersion.FindAllItems(chapterId);

                    foreach (ChapterVersion item in chVersionsList)
                    {
                        item.Deleted = true;
                        dsChapVersion.Update(item);
                    }

                    transaction.Commit();
                }
            }
            catch
            {
                throw new NotImplementedException();
            }
        }