Пример #1
0
        public bool Delete <T>(DeleteConfig config, object deleteObject)
        {
            Type type = typeof(T);

            PropertyInfo[]     properties = type.GetProperties();
            CommandParameter[] parameters = BuildCommandParameters(deleteObject, properties);
            DbCommand          dbCommand  = BuildCommand(config, parameters);
            bool pass = true;

            if (dbTransaction == null)
            {
                try
                {
                    db.ExecuteNonQuery(dbCommand);
                }
                catch (Exception ex)
                {
                    LogHelper.Warn("BlueFramework.Blood.DataAccess.Command.Delete<T> :", ex);
                    pass = false;
                }
            }
            else
            {
                db.ExecuteNonQuery(dbCommand, dbTransaction);
            }
            return(pass);
        }
Пример #2
0
        //FIXME Лучше в будущем разделить тест на разные. Сейчас было лень переписывать код.
        public virtual void NHMappedCollectionsAllInOneTest(PersistentClass mapping, Property prop)
        {
            var  collectionMap      = (prop.Value as Bag);
            Type collectionItemType = null;

            if (collectionMap.Element is OneToMany)
            {
                collectionItemType = (collectionMap.Element as OneToMany).AssociatedClass.MappedClass;
            }
            else if (collectionMap.Element is ManyToOne)
            {
                collectionItemType = (collectionMap.Element as ManyToOne).Type.ReturnedClass;
            }

            var collectionItemClassInfo = DeleteConfig.GetDeleteRule(collectionItemType);

            Assert.That(collectionItemClassInfo, Is.Not.Null,
                        "Класс {0} не имеет правил удаления, но используется в коллекции {1}.{2}.",
                        collectionItemType,
                        mapping.MappedClass.Name,
                        prop.Name);

            var info = DeleteConfig.GetDeleteRule(mapping.MappedClass);

            Assert.That(info, Is.Not.Null,
                        "Коллекция {0}.{1} объектов {2} замаплена в ненастроенном классе.",
                        mapping.MappedClass.Name,
                        prop.Name,
                        collectionItemType.Name);

            if (collectionMap.IsOneToMany)
            {
                var deleteDepend = info.DeleteItems.Find(r => r.ObjectClass == collectionItemType && r.CollectionName == prop.Name);
                Assert.That(deleteDepend, Is.Not.Null,
                            "Для коллекции {0}.{1} не определены зависимости удаления класса {2}",
                            mapping.MappedClass.Name,
                            prop.Name,
                            collectionItemType.Name
                            );
            }
            else
            {
                var removeDepend = collectionItemClassInfo.RemoveFromItems.Find(r => r.ObjectClass == info.ObjectClass && r.CollectionName == prop.Name);
                Assert.That(removeDepend, Is.Not.Null,
                            "Для коллекции {0}.{1} не определены зависимости удаления элементов при удалении класса {2}",
                            mapping.MappedClass.Name,
                            prop.Name,
                            collectionItemType.Name
                            );
            }

            if (collectionItemClassInfo is IHibernateDeleteRule)
            {
                Assert.That(info, Is.InstanceOf <IHibernateDeleteRule>(),
                            "Удаление через Hibernate элементов коллекции {0}.{1}, поддерживается только если удаление родительского класса {0} настроено тоже через Hibernate",
                            mapping.MappedClass.Name,
                            prop.Name
                            );
            }
        }
Пример #3
0
        internal static int Delete(DeleteConfig !config)
        {
            if (config.servers == null)
            {
                Console.WriteLine("no servers given");
                return(-1);
            }

            DNSContract.Imp dnsConn = ((!)config.dnsRef).Acquire();
            if (dnsConn == null)
            {
                Console.WriteLine("Could not initialize DNS endpoint.");
                return(1);
            }
            dnsConn.RecvReady();

            for (int i = 0; i < config.servers.Length; i++)
            {
                IPv4 resolver;
                if (IPv4.Parse(config.servers[i], out resolver) == false)
                {
                    Console.WriteLine("Invalid IP address: {0}", config.servers[i]);
                }

                dnsConn.SendRemoveNameServer((uint)resolver);
                dnsConn.RecvAck();
            }
            delete dnsConn;

            return(0);
        }
Пример #4
0
        internal static int Delete(DeleteConfig !config)
        {
            RoutingContract.Imp routeConn = ((!)config.routingRef).Acquire();
            if (routeConn == null)
            {
                Console.WriteLine("Could not initialize routing endpoint.");
                return(1);
            }
            routeConn.RecvReady();

            IPv4Network destination;

            if (IPv4Network.Parse(config.destination, out destination) == false)
            {
                Console.WriteLine("Could not parse destination address.");
            }

            Network destNet = ChannelUtils.NetworkToChannelNetwork(destination);

            routeConn.SendFindSpecificNetRoute(destNet);

            switch receive {
            case routeConn.NoRouteFound():
                Console.WriteLine("No route for destination.");
                delete routeConn;

                return(-1);

            case routeConn.Route(RouteEntry r):
                // Do nothing; success.
                break;

            case routeConn.ChannelClosed():
                Console.WriteLine("routeConn channel closed.");
                throw new Exception("routeConn channel closed.");
            }

            routeConn.SendDeleteRoute(destNet);

            switch receive {
            case routeConn.NoRouteFound():
                Console.WriteLine("Unexpected error attempting to delete the route");
                break;

            case routeConn.OK():
                Console.WriteLine("Route successfully deleted");
                break;

            case routeConn.ChannelClosed():
                Console.WriteLine("routeConn channel closed");
                throw new Exception("routeConn channel closed");
            }
            delete routeConn;

            return(0);
        }
Пример #5
0
    /// <summary>
    ///     Display a delete dialog.
    /// </summary>
    /// <param name="config">The dialog configuration.</param>
    public virtual IDisposable Delete(DeleteConfig config)
    {
        // If available, call the delegate to see if presenting this dialog is allowed.
        if (MessagingServiceCore.Delegate == null || MessagingServiceCore.Delegate.OnDeleteRequested(config))
        {
            return(PresentDelete(config));
        }

        return(null);
    }
Пример #6
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления в модуле Banks...");

            DeleteConfig.AddHibernateDeleteInfo <BankRegion>()
            .AddDeleteDependence <Bank>(item => item.Region);

            DeleteConfig.AddHibernateDeleteInfo <Bank>()
            .AddDeleteDependence <Account>(item => item.InBank);

            DeleteConfig.AddHibernateDeleteInfo <Account>();
        }
Пример #7
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления в модуле Contacts...");

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(PhoneType),
                SqlSelect     = "SELECT id, name FROM @tablename ",
                DisplayString = "Тип телефона {1}",
                DeleteItems   = new List <DeleteDependenceInfo> {
                    DeleteDependenceInfo.Create <Phone> (item => item.NumberType)
                }
            }.FillFromMetaInfo()
                                       );

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(Phone),
                SqlSelect     = "SELECT id, number, additional FROM @tablename ",
                DisplayString = "Телефон {1} доб. {2}"
            }.FillFromMetaInfo()
                                       );

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(EmailType),
                SqlSelect     = "SELECT id, name FROM @tablename ",
                DisplayString = "Тип E-mail {1}",
                DeleteItems   = new List <DeleteDependenceInfo> {
                    DeleteDependenceInfo.Create <Email> (item => item.EmailType)
                }
            }.FillFromMetaInfo()
                                       );

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(Email),
                SqlSelect     = "SELECT id, address FROM @tablename ",
                DisplayString = "{1}"
            }.FillFromMetaInfo()
                                       );

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(Person),
                SqlSelect     = "SELECT id, surname, name FROM @tablename ",
                DisplayString = "{1} {2}"
            }.FillFromMetaInfo()
                                       );

            DeleteConfig.AddDeleteInfo(new DeleteInfo {
                ObjectClass   = typeof(Post),
                SqlSelect     = "SELECT id, name FROM @tablename ",
                DisplayString = "{1}"
            }.FillFromMetaInfo()
                                       );
        }
Пример #8
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления...");

            DeleteConfig.AddHibernateDeleteInfo <AttachedFile>();

            DeleteConfig.AddHibernateDeleteInfo <BodyMaterial>()
            .AddDeleteDependence <Fitting>(x => x.BodyMaterial);

            DeleteConfig.AddHibernateDeleteInfo <Conductor>()
            .AddDeleteDependence <ProjectItem>(x => x.Conductor);

            DeleteConfig.AddHibernateDeleteInfo <ConnectionType>()
            .AddDeleteDependence <Fitting>(x => x.ConnectionType);

            DeleteConfig.AddHibernateDeleteInfo <Diameter>()
            .AddDeleteDependence <Fitting>(x => x.Diameter);

            DeleteConfig.AddHibernateDeleteInfo <Fitting>()
            .AddDeleteDependence <AttachedFile>(x => x.Fitting)
            .AddDeleteDependence <ProjectItem>(x => x.Fitting)
            .AddDeleteDependence <PriceItem>(x => x.Fitting);

            DeleteConfig.AddHibernateDeleteInfo <FittingType>()
            .AddDeleteDependence <Fitting>(x => x.Name);

            DeleteConfig.AddHibernateDeleteInfo <Pressure>()
            .AddDeleteDependence <Fitting>(x => x.Pressure);

            DeleteConfig.AddHibernateDeleteInfo <PriceItem>()
            .AddClearDependence <ProjectItem>(x => x.SelectedPriceItem);

            DeleteConfig.AddHibernateDeleteInfo <Price>()
            .AddDeleteDependence <PriceItem>(x => x.Price);

            DeleteConfig.AddHibernateDeleteInfo <ProjectItem>();

            DeleteConfig.AddHibernateDeleteInfo <Project>()
            .AddDeleteDependence <ProjectItem>(x => x.Project);

            DeleteConfig.AddHibernateDeleteInfo <Provider>()
            .AddDeleteDependence <Price>(x => x.Provider);

            DeleteConfig.AddHibernateDeleteInfo <User>();

            //Для тетирования
                        #if DEBUG
            DeleteConfig.DeletionCheck();
                        #endif

            logger.Info("Ок");
        }
Пример #9
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления в модуле Banks...");

            DeleteConfig.AddHibernateDeleteInfo <BankRegion>()
            .AddDeleteDependence <Bank>(item => item.Region);

            DeleteConfig.AddHibernateDeleteInfo <Bank>()
            .AddDeleteDependence <Account>(item => item.InBank)
            .AddDeleteDependenceFromCollection(item => item.CorAccounts);

            DeleteConfig.AddHibernateDeleteInfo <Account>()
            .AddClearDependence <Bank>(item => item.DefaultCorAccount);
        }
Пример #10
0
        /// <summary>
        /// Тест наличия каскадной зависимости для ссылок на другие сущьности в класе.
        /// </summary>
        public virtual void CascadeDependenceRuleExisitForNHMappedEntityRelationTest(PersistentClass mapping, Property prop, IDeleteRule related)
        {
            if (IgnoreProperties.ContainsKey(mapping.MappedClass) && IgnoreProperties[mapping.MappedClass].Any(x => x.PropertyName == prop.Name))
            {
                Assert.Ignore(IgnoreProperties[mapping.MappedClass].First(x => x.PropertyName == prop.Name).ReasonForIgnoring);
            }

            var info = DeleteConfig.GetDeleteRule(mapping.MappedClass);

            Assert.That(info.DeleteItems.Any(x => x.ParentPropertyName == prop.Name && x.IsCascade),
                        "Cвойство {0}.{1} не имеет каскадного правила удаления, хотя класс {2} помечен как требующий каскадного удаления.",
                        info.ObjectClass.Name,
                        prop.Name,
                        related.ObjectClass.Name);
        }
Пример #11
0
        public bool Delete(DeleteConfig config, object objectId)
        {
            DbCommand dbCommand = BuildCommand(config, objectId);
            bool      pass      = true;

            if (dbTransaction == null)
            {
                try
                {
                    db.ExecuteNonQuery(dbCommand);
                }
                catch (Exception ex)
                {
                    LogHelper.Warn("BlueFramework.Blood.DataAccess.Command.Delete :", ex);
                    pass = false;
                }
            }
            else
            {
                db.ExecuteNonQuery(dbCommand, dbTransaction);
            }
            return(pass);
        }
Пример #12
0
        public void TransactionTest()
        {
            InsertConfig config = new InsertConfig
            {
                Id             = "test.insertUser",
                Sql            = "insert into [user](username,birthday,address) values(#{UserName},#{Birthday},#{Address})",
                KeyProperty    = "UserId",
                KeyMadeOrder   = IdentityMadeOrder.Inserting,
                KeyPropertySql = "select @UserId=@@IDENTITY"
            };
            UpdateConfig updateConfig = new UpdateConfig
            {
                Id  = "test.insertUser",
                Sql = "update [user] set username=#{UserName} where id=#{UserId}",
            };
            DeleteConfig deleteConfig = new DeleteConfig
            {
                Id  = "test.deleteUser",
                Sql = "delete from [user] where id=#{value}",
            };
            int insertCount = 0;
            int beginId     = 0;

            using (var command = new Command())
            {
                try
                {
                    command.BeginTransaction();
                    for (int i = 0; i < 10; i++)
                    {
                        UserInfo userInfo = new UserInfo()
                        {
                            UserId   = 0,
                            UserName = "******" + i.ToString(),
                            Birthday = DateTime.Now
                        };
                        UserInfo o = command.Insert <UserInfo>(config, userInfo);
                        insertCount++;
                        if (o != null && i == 0)
                        {
                            beginId = o.UserId;
                        }
                    }

                    for (int i = 0; i < 5; i++)
                    {
                        UserInfo userInfo = new UserInfo()
                        {
                            UserId   = i + 50,
                            UserName = "******" + i.ToString(),
                            Birthday = DateTime.Now
                        };
                        command.Update <UserInfo>(updateConfig, userInfo);
                    }

                    for (int i = beginId; i <= beginId + 5; i++)
                    {
                        command.Delete(deleteConfig, i);
                    }

                    command.CommitTransaction();
                }
                catch (Exception ex)
                {
                    command.RollbackTransaction();
                }
            }
            Assert.AreEqual(insertCount, 10);
        }
Пример #13
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления...");

            #region Связь
            DeleteConfig.AddHibernateDeleteInfo <MessageTemplate>();
            #endregion
            #region Организация

            DeleteConfig.AddHibernateDeleteInfo <Department>()
            .AddClearDependence <EmployeeCard>(x => x.Department)
            .AddClearDependence <Post>(x => x.Department);

            DeleteConfig.AddHibernateDeleteInfo <EmployeeCard>()
            .AddDeleteDependence <EmployeeCardItem>(x => x.EmployeeCard)
            .AddDeleteDependence <EmployeeVacation>(x => x.Employee)
            .AddDeleteDependence <Expense>(x => x.Employee)
            .AddDeleteDependence <CollectiveExpenseItem>(x => x.Employee)
            .AddDeleteDependence <Income>(x => x.EmployeeCard)
            .AddDeleteDependence <EmployeeIssueOperation>(x => x.Employee)
            .AddDeleteDependence <EmployeeSize>(x => x.Employee)
            .AddDeleteDependence <IssuanceSheetItem>(x => x.Employee)
            .AddClearDependence <Leader>(x => x.Employee);

            DeleteConfig.AddHibernateDeleteInfo <EmployeeCardItem>();

            DeleteConfig.AddHibernateDeleteInfo <EmployeeVacation>();

            DeleteConfig.AddHibernateDeleteInfo <Leader>()
            .AddClearDependence <EmployeeCard>(x => x.Leader)
            .AddClearDependence <IssuanceSheet>(x => x.HeadOfDivisionPerson)
            .AddClearDependence <IssuanceSheet>(x => x.ResponsiblePerson)
            .AddClearDependence <UserSettings>(x => x.DefaultResponsiblePerson)
            .AddClearDependence <UserSettings>(x => x.DefaultLeader);

            DeleteConfig.AddHibernateDeleteInfo <Organization>()
            .AddClearDependence <IssuanceSheet>(x => x.Organization)
            .AddClearDependence <UserSettings>(x => x.DefaultOrganization);

            DeleteConfig.AddHibernateDeleteInfo <Post>()
            .AddRemoveFromDependence <Norm>(x => x.Posts)
            .AddClearDependence <EmployeeCard>(x => x.Post);

            DeleteConfig.AddHibernateDeleteInfo <Subdivision>()
            .AddDeleteDependence <Department>(x => x.Subdivision)
            .AddDeleteDependence <SubdivisionPlace>(x => x.Subdivision)
            .AddDeleteDependence <Expense>(x => x.Subdivision)
            .AddDeleteDependence <Income>(x => x.Subdivision)
            .AddDeleteDependence <SubdivisionIssueOperation>(x => x.Subdivision)
            .AddClearDependence <EmployeeCard>(x => x.Subdivision)
            .AddClearDependence <Post>(x => x.Subdivision)
            .AddClearDependence <IssuanceSheet>(x => x.Subdivision)
            .AddClearDependence <Subdivision>(x => x.ParentSubdivision);

            DeleteConfig.AddHibernateDeleteInfo <SubdivisionPlace>()
            .AddClearDependence <ExpenseItem>(x => x.SubdivisionPlace)
            .AddClearDependence <SubdivisionIssueOperation>(x => x.SubdivisionPlace);

            DeleteConfig.AddHibernateDeleteInfo <VacationType>()
            .AddDeleteDependence <EmployeeVacation>(x => x.VacationType);

            #endregion
            #region Нормы выдачи

            DeleteConfig.AddHibernateDeleteInfo <Norm>()
            .AddRemoveFromDependence <EmployeeCard>(x => x.UsedNorms, x => x.RemoveUsedNorm)
            .AddDeleteDependence <NormItem>(x => x.Norm);

            DeleteConfig.AddHibernateDeleteInfo <NormItem>()
            .AddClearDependence <EmployeeIssueOperation>(x => x.NormItem)
            //Ну нужна так как должна удалятся через пересчет. .AddClearDependence<EmployeeCardItem> (x => x.ActiveNormItem) //FIXME После этого нужно пересчитать требования к выдаче, то новому списку норм.
            ;

            DeleteConfig.AddHibernateDeleteInfo <NormCondition>()
            .AddClearDependence <NormItem>(x => x.NormCondition);

            DeleteConfig.AddHibernateDeleteInfo <Profession>()
            .AddClearDependence <Post>(x => x.Profession);

            DeleteConfig.AddHibernateDeleteInfo <ProtectionTools>()
            .AddDeleteDependence <EmployeeCardItem>(x => x.ProtectionTools)
            .AddDeleteDependence <NormItem>(x => x.ProtectionTools)
            .AddDeleteDependence <IssuanceSheetItem>(x => x.ProtectionTools)
            .AddClearDependence <ExpenseItem>(x => x.ProtectionTools)
            .AddClearDependence <CollectiveExpenseItem>(x => x.ProtectionTools)
            .AddClearDependence <EmployeeIssueOperation>(x => x.ProtectionTools);

            DeleteConfig.AddHibernateDeleteInfo <RegulationDoc>()
            .AddDeleteDependence <Norm>(x => x.Document)
            .AddDeleteDependence <RegulationDocAnnex>(x => x.Document);

            DeleteConfig.AddHibernateDeleteInfo <RegulationDocAnnex>()
            .AddClearDependence <Norm>(x => x.Annex);

            #endregion
            #region Склад

            DeleteConfig.AddHibernateDeleteInfo <Warehouse>()
            .AddDeleteDependence <Income>(x => x.Warehouse)
            .AddDeleteDependence <Expense>(x => x.Warehouse)
            .AddDeleteDependence <CollectiveExpense>(x => x.Warehouse)
            .AddDeleteDependence <WriteoffItem>(x => x.Warehouse)
            .AddDeleteDependence <Transfer>(x => x.WarehouseFrom)
            .AddDeleteDependence <Transfer>(x => x.WarehouseTo)
            .AddDeleteDependence <WarehouseOperation>(x => x.ReceiptWarehouse)
            .AddDeleteDependence <WarehouseOperation>(x => x.ExpenseWarehouse)
            .AddClearDependence <Subdivision>(x => x.Warehouse)
            .AddClearDependence <UserSettings>(x => x.DefaultWarehouse)
            .AddDeleteDependence <Completion>(x => x.ResultWarehouse)
            .AddDeleteDependence <Completion>(x => x.SourceWarehouse);

            DeleteConfig.AddHibernateDeleteInfo <MeasurementUnits>()
            .AddClearDependence <ItemsType>(x => x.Units);

            DeleteConfig.AddHibernateDeleteInfo <Nomenclature> ()
            .AddDeleteDependence <ExpenseItem> (x => x.Nomenclature)
            .AddDeleteDependence <CollectiveExpenseItem> (x => x.Nomenclature)
            .AddDeleteDependence <IncomeItem> (x => x.Nomenclature)
            .AddDeleteDependence <WriteoffItem> (x => x.Nomenclature)
            .AddDeleteDependence <TransferItem>(x => x.Nomenclature)
            .AddDeleteDependence <EmployeeIssueOperation>(x => x.Nomenclature)
            .AddDeleteDependence <SubdivisionIssueOperation>(x => x.Nomenclature)
            .AddDeleteDependence <WarehouseOperation>(x => x.Nomenclature)
            .AddDeleteDependence <IssuanceSheetItem>(x => x.Nomenclature);

            DeleteConfig.AddHibernateDeleteInfo <Expense> ()
            .AddDeleteDependence <ExpenseItem> (x => x.ExpenseDoc)
            .AddDeleteDependence <IssuanceSheet>(x => x.Expense);

            DeleteConfig.AddHibernateDeleteInfo <ExpenseItem> ()
            .AddDeleteDependence <IssuanceSheetItem>(x => x.ExpenseItem)
            .AddDeleteCascadeDependence(x => x.EmployeeIssueOperation)
            .AddDeleteCascadeDependence(x => x.SubdivisionIssueOperation)
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);

            DeleteConfig.AddHibernateDeleteInfo <CollectiveExpense>()
            .AddDeleteDependence <CollectiveExpenseItem>(x => x.Document)
            .AddDeleteDependence <IssuanceSheet>(x => x.CollectiveExpense);

            DeleteConfig.AddHibernateDeleteInfo <CollectiveExpenseItem> ()
            .AddDeleteDependence <IssuanceSheetItem>(x => x.CollectiveExpenseItem)
            .AddDeleteCascadeDependence(x => x.EmployeeIssueOperation)
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);

            DeleteConfig.AddHibernateDeleteInfo <Income> ()
            .AddDeleteDependence <IncomeItem>(x => x.Document);

            DeleteConfig.AddHibernateDeleteInfo <IncomeItem> ()
            .AddDeleteCascadeDependence(x => x.ReturnFromEmployeeOperation)
            .AddDeleteCascadeDependence(x => x.ReturnFromSubdivisionOperation)
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);

            DeleteConfig.AddHibernateDeleteInfo <ItemsType>()
            .AddDeleteDependence <Nomenclature>(x => x.Type)
            .AddDeleteDependence <ProtectionTools>(x => x.Type);

            DeleteConfig.AddHibernateDeleteInfo <Writeoff> ()
            .AddDeleteDependence <WriteoffItem>(x => x.Document)
            .AddClearDependence <Expense>(x => x.WriteOffDoc);

            DeleteConfig.AddHibernateDeleteInfo <WriteoffItem> ()
            .AddRemoveFromDependence <Writeoff>(x => x.Items)                   //Необходимо иначе будут исключения при удалении строк выдачи которые создают списание.
            .AddDeleteCascadeDependence(x => x.EmployeeWriteoffOperation)
            .AddDeleteCascadeDependence(x => x.SubdivisionWriteoffOperation)
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);

            DeleteConfig.AddHibernateDeleteInfo <Transfer>()
            .AddDeleteDependence <TransferItem>(x => x.Document);

            DeleteConfig.AddHibernateDeleteInfo <TransferItem>()
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);

            DeleteConfig.AddHibernateDeleteInfo <Completion>()
            .AddDeleteDependence <CompletionSourceItem>(x => x.Completion)
            .AddDeleteDependence <CompletionResultItem>(x => x.Completion);

            DeleteConfig.AddHibernateDeleteInfo <CompletionSourceItem>()
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);
            DeleteConfig.AddHibernateDeleteInfo <CompletionResultItem>()
            .AddDeleteCascadeDependence(x => x.WarehouseOperation);
            #endregion
            #region Statements

            DeleteConfig.AddHibernateDeleteInfo <IssuanceSheet>()
            .AddDeleteDependence <IssuanceSheetItem>(x => x.IssuanceSheet);

            DeleteConfig.AddHibernateDeleteInfo <IssuanceSheetItem>();

            #endregion
            #region Операции

            DeleteConfig.AddHibernateDeleteInfo <EmployeeIssueOperation>()
            .RequiredCascadeDeletion()
            .AddDeleteDependence <EmployeeIssueOperation>(x => x.IssuedOperation)
            .AddDeleteDependence <ExpenseItem>(x => x.EmployeeIssueOperation)
            .AddDeleteDependence <CollectiveExpenseItem>(x => x.EmployeeIssueOperation)
            .AddDeleteDependence <IncomeItem>(x => x.ReturnFromEmployeeOperation)
            .AddDeleteDependence <WriteoffItem>(x => x.EmployeeWriteoffOperation)
            .AddDeleteCascadeDependence(x => x.EmployeeOperationIssueOnWriteOff)
            .AddClearDependence <IssuanceSheetItem>(x => x.IssueOperation)
            .AddClearDependence <EmployeeIssueOperation>(x => x.EmployeeOperationIssueOnWriteOff);

            DeleteConfig.AddHibernateDeleteInfo <SubdivisionIssueOperation>()
            .RequiredCascadeDeletion()
            .AddDeleteDependence <SubdivisionIssueOperation>(x => x.IssuedOperation)
            .AddDeleteDependence <ExpenseItem>(x => x.SubdivisionIssueOperation)
            .AddDeleteDependence <IncomeItem>(x => x.ReturnFromSubdivisionOperation)
            .AddDeleteDependence <WriteoffItem>(x => x.SubdivisionWriteoffOperation);

            DeleteConfig.AddHibernateDeleteInfo <WarehouseOperation>()
            .RequiredCascadeDeletion()
            .AddDeleteDependence <ExpenseItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <CollectiveExpenseItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <IncomeItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <WriteoffItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <TransferItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <EmployeeIssueOperation>(x => x.WarehouseOperation)
            .AddDeleteDependence <SubdivisionIssueOperation>(x => x.WarehouseOperation)
            .AddDeleteDependence <CompletionResultItem>(x => x.WarehouseOperation)
            .AddDeleteDependence <CompletionSourceItem>(x => x.WarehouseOperation);

            #endregion
            #region Пользователь

            DeleteConfig.AddHibernateDeleteInfo <UserBase>()
            .AddDeleteDependence <UserSettings>(x => x.User)
            .AddClearDependence <EmployeeCard>(x => x.CreatedbyUser)
            .AddClearDependence <Writeoff>(x => x.CreatedbyUser)
            .AddClearDependence <Expense>(x => x.CreatedbyUser)
            .AddClearDependence <CollectiveExpense>(x => x.CreatedbyUser)
            .AddClearDependence <Income>(x => x.CreatedbyUser)
            .AddClearDependence <Transfer>(x => x.CreatedbyUser)
            .AddClearDependence <Completion>(x => x.CreatedbyUser);

            DeleteConfig.AddHibernateDeleteInfo <UserSettings>();

            #endregion
            #region  азмеры

            DeleteConfig.AddHibernateDeleteInfo <Size>()
            .AddClearDependence <CollectiveExpenseItem>(x => x.Height)
            .AddClearDependence <CollectiveExpenseItem>(x => x.WearSize)
            .AddClearDependence <EmployeeIssueOperation>(x => x.Height)
            .AddClearDependence <EmployeeIssueOperation>(x => x.WearSize)
            .AddClearDependence <ExpenseItem>(x => x.Height)
            .AddClearDependence <ExpenseItem>(x => x.WearSize)
            .AddClearDependence <IncomeItem>(x => x.Height)
            .AddClearDependence <IncomeItem>(x => x.WearSize)
            .AddClearDependence <IssuanceSheetItem>(x => x.Height)
            .AddClearDependence <IssuanceSheetItem>(x => x.WearSize)
            .AddClearDependence <SubdivisionIssueOperation>(x => x.Height)
            .AddClearDependence <SubdivisionIssueOperation>(x => x.WearSize)
            .AddClearDependence <WarehouseOperation>(x => x.Height)
            .AddClearDependence <WarehouseOperation>(x => x.WearSize)
            .AddClearDependence <WriteoffItem>(x => x.Height)
            .AddClearDependence <WriteoffItem>(x => x.WearSize)
            .AddDeleteDependence <EmployeeSize>(x => x.Size);


            DeleteConfig.AddHibernateDeleteInfo <SizeType>()
            .AddDeleteDependence <Size>(x => x.SizeType)
            .AddDeleteDependence <EmployeeSize>(x => x.SizeType)
            .AddClearDependence <ItemsType>(x => x.SizeType)
            .AddClearDependence <ItemsType>(x => x.HeightType);

            DeleteConfig.AddHibernateDeleteInfo <EmployeeSize>();
            #endregion
            logger.Info("Ок");
        }
Пример #14
0
        public static void ConfigureDeletion()
        {
            logger.Info("Настройка параметров удаления...");

            QSContactsMain.ConfigureDeletion();
            QSBanksMain.ConfigureDeletion();

            DeleteConfig.AddClearDependence <Post> (ClearDependenceInfo.Create <Contact> (item => item.Post));
            DeleteConfig.AddClearDependence <Account> (ClearDependenceInfo.Create <Organization> (item => item.DefaultAccount));
            DeleteConfig.AddClearDependence <Account> (ClearDependenceInfo.Create <Counterparty> (item => item.DefaultAccount));

            #region Client

            DeleteConfig.AddHibernateDeleteInfo <Contact>()
            .AddDeleteDependenceFromBag(item => item.Emails)
            .AddDeleteDependenceFromBag(item => item.Phones)
            .AddRemoveFromDependence <DeliveryPoint>(x => x.Contacts);

            DeleteConfig.AddHibernateDeleteInfo <Contract>().HasSubclasses()
            ;
            DeleteConfig.AddHibernateDeleteInfo <ContractLongLease>()
            .AddDeleteDependence <ContractLongLeaseAddress>(x => x.Contract);

            DeleteConfig.AddHibernateDeleteInfo <ContractLongLeaseAddress>();

            DeleteConfig.AddHibernateDeleteInfo <ContractMaintenance>()
            .AddDeleteDependence <ContractMaintenanceAddress>(x => x.Contract);

            DeleteConfig.AddHibernateDeleteInfo <ContractMaintenanceAddress>();

            DeleteConfig.AddHibernateDeleteInfo <ContractShortLease>()
            .AddDeleteDependence <ContractShortLeaseAddress>(x => x.Contract);

            DeleteConfig.AddHibernateDeleteInfo <ContractShortLeaseAddress>()
            ;

            DeleteConfig.AddHibernateDeleteInfo <Counterparty>()
            .AddDeleteDependence <Contact>(x => x.Counterparty)
            .AddDeleteDependence <Contract>(x => x.Counterparty)
            .AddDeleteDependence <DeliveryPoint>(x => x.Counterparty)
            .AddDeleteDependenceFromBag(item => item.Emails)
            .AddDeleteDependenceFromBag(item => item.Phones)
            .AddDeleteDependenceFromBag(item => item.Accounts);

            DeleteConfig.AddHibernateDeleteInfo <DeliveryPoint>()
            .AddDeleteDependence <ContractLongLeaseAddress>(x => x.DeliveryPoint)
            .AddDeleteDependence <ContractShortLeaseAddress>(x => x.DeliveryPoint)
            .AddDeleteDependence <ContractMaintenanceAddress>(x => x.DeliveryPoint)
            //.AddDeleteDependenceFromBag(x => x.Contacts) FIXME сделать чтобы работало.
            ;

            DeleteConfig.AddHibernateDeleteInfo <DocTemplate>()
            .AddClearDependence <Contract>(x => x.ContractTemplate);

            #endregion
            #region Company

            DeleteConfig.AddHibernateDeleteInfo <CabineColor>()
            .AddClearDependence <Cabine>(x => x.Color);

            DeleteConfig.AddHibernateDeleteInfo <Cabine>()
            .AddRemoveFromDependence <ContractLongLeaseAddress>(x => x.Cabines);

            DeleteConfig.AddHibernateDeleteInfo <Employee>()
            .AddClearDependence <Counterparty>(x => x.PaymentManager)
            .AddClearDependence <Organization>(x => x.Buhgalter)
            .AddClearDependence <Organization>(x => x.Leader)
            .AddDeleteDependenceFromBag(x => x.Phones);

            DeleteConfig.AddHibernateDeleteInfo <Organization>()
            .AddDeleteDependence <Contract>(x => x.Organization)
            .AddDeleteDependenceFromBag(x => x.Phones)
            .AddDeleteDependenceFromBag(x => x.Accounts);

            DeleteConfig.AddHibernateDeleteInfo <User>()
            .AddClearDependence <Employee>(x => x.User);

            #endregion

            //Для тетирования
                        #if DEBUG
            DeleteConfig.IgnoreMissingClass.Add(typeof(ContactAndPhonesView));

            DeleteConfig.DeletionCheck();
                        #endif

            logger.Info("Ок");
        }