コード例 #1
0
        private GroupCode addGroupCode1(string paramString1, string paramString2)
        {
            GroupCodeTable groupCodeTable = new GroupCodeTable();

            groupCodeTable.GroupCode   = paramString1;
            groupCodeTable.Title       = paramString2;
            groupCodeTable.Notes       = "";
            groupCodeTable.Unit        = "";
            groupCodeTable.UnitFactor  = BigDecimalMath.ONE;
            groupCodeTable.Unit        = "";
            groupCodeTable.EditorId    = "admin";
            groupCodeTable.Description = "";
            groupCodeTable.LastUpdate  = this.lastUpdate;
            return(groupCodeTable);
        }
コード例 #2
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private SPONMigrationUtil(String paramString1, String paramString2) throws Exception
        private SPONMigrationUtil(string paramString1, string paramString2)
        {
            initializeRateConverter();
            this.sponLineItemList = SponLineTimeLoader.loadLineItems(paramString1, paramString2);
            System.Collections.IEnumerator iterator1 = this.sponLineItemList.GetEnumerator();
            this.rootNode = new DefaultMutableTreeNode();
            sbyte b;

            for (b = 0; iterator1.MoveNext(); b++)
            {
                SponLineItem sponLineItem = (SponLineItem)iterator1.Current;
                sponLineItem.Index = b;
                DefaultMutableTreeNode defaultMutableTreeNode = findParentForLineItem(sponLineItem, b);
                defaultMutableTreeNode.add(sponLineItem);
            }
            System.Collections.IEnumerator enumeration = this.rootNode.children();
            LinkedList linkedList = new LinkedList();

            while (enumeration.MoveNext())
            {
                linkedList.AddLast(enumeration.Current);
            }
            Hashtable hashMap = new Hashtable();

            foreach (SponLineItem sponLineItem1 in linkedList)
            {
                SponLineItem sponLineItem2 = null;
                LinkedList   linkedList1   = null;
                System.Collections.IEnumerator enumeration1 = sponLineItem1.children();
                Console.WriteLine("" + sponLineItem1);
                while (enumeration1.MoveNext())
                {
                    SponLineItem sponLineItem = (SponLineItem)enumeration1.Current;
                    string       str          = sponLineItem.Code;
                    if (str.IndexOf("/", StringComparison.Ordinal) != -1)
                    {
                        if (str.IndexOf("N", StringComparison.Ordinal) == -1)
                        {
                            str = StringHelper.SubstringSpecial(str, str.IndexOf("/", StringComparison.Ordinal) + 1, str.Length);
                        }
                        else
                        {
                            str = StringHelper.SubstringSpecial(str, str.IndexOf("/", StringComparison.Ordinal), str.Length);
                        }
                    }
                    if (str.Length == 3)
                    {
                        sponLineItem2          = sponLineItem;
                        linkedList1            = new LinkedList();
                        hashMap[sponLineItem2] = linkedList1;
                        Console.WriteLine(" " + sponLineItem);
                        continue;
                    }
                    if (linkedList1 == null)
                    {
                        Console.WriteLine("I was trying;" + sponLineItem);
                    }
                    linkedList1.AddLast(sponLineItem);
                }
            }
            foreach (SponLineItem sponLineItem in hashMap.Keys)
            {
                foreach (SponLineItem sponLineItem1 in (System.Collections.IList)hashMap[sponLineItem])
                {
                    sponLineItem1.removeFromParent();
                }
                foreach (SponLineItem sponLineItem1 in (System.Collections.IList)hashMap[sponLineItem])
                {
                    sponLineItem.add(sponLineItem1);
                }
            }
            Session     session     = DatabaseDBUtil.currentSession();
            Transaction transaction = session.beginTransaction();

            try
            {
                Console.WriteLine("\n\n\n\n");
                enumeration = this.rootNode.preorderEnumeration();
                b           = 0;
                while (enumeration.MoveNext())
                {
                    DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode)enumeration.Current;
                    if (defaultMutableTreeNode.Root)
                    {
                        continue;
                    }
                    SponLineItem sponLineItem = (SponLineItem)defaultMutableTreeNode;
                    string       str1         = null;
                    string       str2         = sponLineItem.Code;
                    if (++b % 'Ǵ' == '\x0000')
                    {
                        Console.WriteLine("PROCESSED: " + b + " lines");
                        transaction.commit();
                        DatabaseDBUtil.closeSession();
                        session     = DatabaseDBUtil.currentSession();
                        transaction = session.beginTransaction();
                    }
                    if (b % '✐' == '\x0000')
                    {
                        Thread.Sleep(2000L);
                    }
                    if (sponLineItem.Composite)
                    {
                        if (defaultMutableTreeNode.Path.length == 2)
                        {
                            str1 = str2;
                        }
                        else if (defaultMutableTreeNode.Path.length == 3)
                        {
                            str1 = str2.Substring(0, 1) + "." + str2.Substring(1, str2.Length - 1);
                        }
                        else if (defaultMutableTreeNode.Path.length == 4)
                        {
                            string str4 = ((SponLineItem)defaultMutableTreeNode.Parent).WbsCode;
                            string str5 = StringHelper.SubstringSpecial(str2, str4.Length - 1 - "C".Length, str2.Length);
                            str1 = str4 + "." + str5;
                        }
                        else
                        {
                            SponLineItem sponLineItem1 = (SponLineItem)defaultMutableTreeNode.Parent;
                            string       str           = sponLineItem1.WbsCode;
                            sbyte        b2            = 1;
                            System.Collections.IEnumerator enumeration1 = sponLineItem1.children();
                            while (enumeration1.MoveNext())
                            {
                                SponLineItem sponLineItem2 = (SponLineItem)enumeration1.Current;
                                if (sponLineItem2.Equals(sponLineItem))
                                {
                                    break;
                                }
                                b2++;
                            }
                            str1 = str + "." + b2;
                        }
                    }
                    string str3 = "";
                    for (sbyte b1 = 1; b1 < defaultMutableTreeNode.Path.length; b1++)
                    {
                        str3 = str3 + " ";
                    }
                    if (sponLineItem.Composite)
                    {
                        if (sponLineItem.Depth == 1)
                        {
                            System.Collections.IEnumerator enumeration1 = sponLineItem.children();
                            while (enumeration1.MoveNext())
                            {
                                SponLineItem sponLineItem1 = (SponLineItem)enumeration1.Current;
                                sponLineItem1.MoreDescription.Add(sponLineItem.Description);
                                if (!string.ReferenceEquals(sponLineItem.SecondDescription, null))
                                {
                                    sponLineItem1.MoreSecondDescription.Add(sponLineItem.SecondDescription);
                                }
                            }
                            continue;
                        }
                        if (sponLineItem.ChildCount == 0)
                        {
                            bool         @bool         = sponLineItem.NoteItem;
                            SponLineItem sponLineItem1 = (SponLineItem)defaultMutableTreeNode.Parent;
                            System.Collections.IEnumerator enumeration1 = sponLineItem1.children();
                            bool bool1 = false;
                            while (enumeration1.MoveNext())
                            {
                                SponLineItem sponLineItem2 = (SponLineItem)enumeration1.Current;
                                if (sponLineItem2.Equals(sponLineItem))
                                {
                                    bool1 = true;
                                    continue;
                                }
                                if (bool1 == true)
                                {
                                    if (@bool)
                                    {
                                        sponLineItem2.Notes = sponLineItem.Description;
                                        setNotesToAllSubItems(sponLineItem2, sponLineItem2.Notes);
                                        continue;
                                    }
                                    if (sponLineItem2.NoteItem)
                                    {
                                        string str = sponLineItem2.Description;
                                        sponLineItem2.Description = sponLineItem.Description;
                                        sponLineItem2.Notes       = str;
                                        setNotesToAllSubItems(sponLineItem2, sponLineItem2.Notes);
                                        sponLineItem.Notes = sponLineItem2.Description;
                                    }
                                }
                            }
                            continue;
                        }
                        if (sponLineItem.NoteItem)
                        {
                            setNotesToAllSubItems(sponLineItem, sponLineItem.Description);
                        }
                    }
                    if (!string.ReferenceEquals(str1, null))
                    {
                        if (!str1.StartsWith("C", StringComparison.Ordinal))
                        {
                            sponLineItem.WbsCode = "C" + str1;
                        }
                        else
                        {
                            sponLineItem.WbsCode = str1;
                        }
                        GroupCodeTable groupCodeTable = new GroupCodeTable();
                        groupCodeTable.GroupCode   = sponLineItem.WbsCode;
                        groupCodeTable.Title       = sponLineItem.makeShortTitle();
                        groupCodeTable.Unit        = "";
                        groupCodeTable.UnitFactor  = BigDecimalMath.ONE;
                        groupCodeTable.Description = sponLineItem.Description + "\n" + sponLineItem.Notes;
                        groupCodeTable.Notes       = sponLineItem.Code;
                        groupCodeTable.EditorId    = "spon";
                        session.save(groupCodeTable);
                        continue;
                    }
                    processSponCostItem(sponLineItem, session);
                }
                transaction.commit();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.ToString());
                Console.Write(exception.StackTrace);
                transaction.rollback();
            }
            DatabaseDBUtil.closeSession();
            Console.WriteLine("\n\n\n\nUNIT MAP TO CONVERT:");
            System.Collections.IEnumerator iterator2 = this.unitMap.Values.GetEnumerator();
            while (iterator2.MoveNext())
            {
                Console.WriteLine(iterator2.Current);
            }
        }
コード例 #3
0
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        //ORIGINAL LINE: private void loadLineItems(org.hibernate.Session paramSession, String paramString) throws Exception
        private void loadLineItems(Session paramSession, string paramString)
        {
            POIFSFileSystem pOIFSFileSystem = new POIFSFileSystem(new FileStream(paramString, FileMode.Open, FileAccess.Read));
            HSSFWorkbook    hSSFWorkbook    = new HSSFWorkbook(pOIFSFileSystem);

            this.o_evaluator = hSSFWorkbook.CreationHelper.createFormulaEvaluator();
            HSSFSheet hSSFSheet = hSSFWorkbook.getSheetAt(0);

            Console.WriteLine("Loading Line Items...");
            int            i              = getRealNumberOfRows(hSSFSheet);
            string         str1           = null;
            string         str2           = null;
            GroupCodeTable groupCodeTable = null;
            string         str3           = null;

            for (int j = 1; j < i; j++)
            {
                if (j % this.rowsToCommit == 0)
                {
                    paramSession.Transaction.commit();
                    paramSession.Transaction.begin();
                    Console.WriteLine("Processing next 500...");
                }
                HSSFRow hSSFRow = hSSFSheet.getRow(j);
                string  str4    = notNull(hSSFRow.getCell(0));
                string  str5    = notNull(hSSFRow.getCell(1));
                if (!str4.StartsWith("Group", StringComparison.Ordinal))
                {
                    string str6 = notNull(hSSFRow.getCell(2));
                    string str7 = notNull(hSSFRow.getCell(3));
                    if (!StringUtils.isNullOrBlank(str4))
                    {
                        Console.WriteLine(str6 + " - " + str7);
                        str1 = str4;
                        str1 = StringUtils.replaceAll(str1, ".", "");
                        str1 = StringUtils.replaceAll(str1, "-", "");
                        str1 = str1.Substring(0, 4);
                        str3 = str1;
                        GroupCode groupCode = addGroupCode1(str1, str7);
                        this.dprPhaseMap[str6] = groupCode;
                        paramSession.save(groupCode);
                    }
                    else if (!StringUtils.isNullOrBlank(str5))
                    {
                        Console.WriteLine(str6 + " - " + str7);
                        str2 = str5;
                        str2 = StringUtils.replaceAll(str2, ".", "");
                        str2 = StringUtils.replaceAll(str2, "-", "");
                        str1 = str2.Substring(0, 4);
                        str2 = str2.Substring(4, str2.Length - 4);
                        GroupCode groupCode = addGroupCode1(str3 + "." + str2, str7);
                        this.dprPhaseMap[str6] = groupCode;
                        long?long                  = (long?)paramSession.save(groupCode);
                        groupCodeTable             = (GroupCodeTable)groupCode;
                        groupCodeTable.GroupCodeId = long;
                    }
                    else
                    {
                        decimal bigDecimal1  = notNullBigDecimal(hSSFRow.getCell(4), 1.0D);
                        string  str8         = toCorrectUnit(notNull(hSSFRow.getCell(5)));
                        string  str9         = notNull(hSSFRow.getCell(6));
                        decimal bigDecimal2  = notNullBigDecimal(hSSFRow.getCell(7), 0.0D);
                        string  str10        = toCorrectUnit(notNull(hSSFRow.getCell(8)));
                        decimal bigDecimal3  = notNullBigDecimal(hSSFRow.getCell(9), 0.0D);
                        string  str11        = toCorrectUnit(notNull(hSSFRow.getCell(10)));
                        decimal bigDecimal4  = notNullBigDecimal(hSSFRow.getCell(11), 0.0D);
                        string  str12        = notNull(hSSFRow.getCell(12)).ToUpper();
                        decimal bigDecimal5  = notNullBigDecimal(hSSFRow.getCell(13), 0.0D);
                        string  str13        = toCorrectUnit(notNull(hSSFRow.getCell(14)));
                        decimal bigDecimal6  = notNullBigDecimal(hSSFRow.getCell(15), 0.0D);
                        decimal bigDecimal7  = notNullBigDecimal(hSSFRow.getCell(16), 1.0D);
                        string  str14        = toCorrectUnit(notNull(hSSFRow.getCell(17)));
                        decimal bigDecimal8  = notNullBigDecimal(hSSFRow.getCell(18), 1.0D);
                        string  str15        = toCorrectUnit(notNull(hSSFRow.getCell(19)));
                        decimal bigDecimal9  = notNullBigDecimal(hSSFRow.getCell(20), 0.0D);
                        string  str16        = toCorrectUnit(notNull(hSSFRow.getCell(21)));
                        decimal bigDecimal10 = notNullBigDecimal(hSSFRow.getCell(22), 0.0D);
                        decimal bigDecimal11 = notNullBigDecimal(hSSFRow.getCell(23), 0.0D);
                        string  str17        = toCorrectUnit(notNull(hSSFRow.getCell(24)));
                        decimal bigDecimal12 = notNullBigDecimal(hSSFRow.getCell(25), 0.0D);
                        string  str18        = toCorrectUnit(notNull(hSSFRow.getCell(26)));
                        decimal bigDecimal13 = notNullBigDecimal(hSSFRow.getCell(27), 0.0D);
                        string  str19        = toCorrectUnit(notNull(hSSFRow.getCell(28)));
                        decimal bigDecimal14 = notNullBigDecimal(hSSFRow.getCell(29), 0.0D);
                        string  str20        = toCorrectUnit(notNull(hSSFRow.getCell(30)));
                        decimal bigDecimal15 = notNullBigDecimal(hSSFRow.getCell(31), 0.0D);
                        decimal bigDecimal16 = notNullBigDecimal(hSSFRow.getCell(32), 1.0D);
                        string  str21        = toCorrectUnit(notNull(hSSFRow.getCell(33)));
                        decimal bigDecimal17 = notNullBigDecimal(hSSFRow.getCell(34), 0.0D);
                        string  str22        = toCorrectUnit(notNull(hSSFRow.getCell(35)));
                        decimal bigDecimal18 = notNullBigDecimal(hSSFRow.getCell(36), 1.0D);
                        string  str23        = toCorrectUnit(notNull(hSSFRow.getCell(37)));
                        decimal bigDecimal19 = notNullBigDecimal(hSSFRow.getCell(38), 0.0D);
                        string  str24        = toCorrectUnit(notNull(hSSFRow.getCell(39)));
                        decimal bigDecimal20 = notNullBigDecimal(hSSFRow.getCell(40), 0.0D);
                        decimal bigDecimal21 = notNullBigDecimal(hSSFRow.getCell(41), 0.0D);
                        string  str25        = toCorrectUnit(notNull(hSSFRow.getCell(42)));
                        decimal bigDecimal22 = notNullBigDecimal(hSSFRow.getCell(43), 0.0D);
                        string  str26        = toCorrectUnit(notNull(hSSFRow.getCell(44)));
                        decimal bigDecimal23 = notNullBigDecimal(hSSFRow.getCell(45), 0.0D);
                        string  str27        = toCorrectUnit(notNull(hSSFRow.getCell(46)));
                        decimal bigDecimal24 = notNullBigDecimal(hSSFRow.getCell(47), 0.0D);
                        string  str28        = toCorrectUnit(notNull(hSSFRow.getCell(48)));
                        decimal bigDecimal25 = notNullBigDecimal(hSSFRow.getCell(49), 0.0D);
                        decimal bigDecimal26 = notNullBigDecimal(hSSFRow.getCell(50), 0.0D);
                        string  str29        = toCorrectUnit(notNull(hSSFRow.getCell(51)));
                        decimal bigDecimal27 = notNullBigDecimal(hSSFRow.getCell(52), 0.0D);
                        Console.WriteLine(str6 + " - " + str7 + " " + str8 + " " + bigDecimal1 + " " + str9 + " " + bigDecimal27);
                        string        str30         = notNull(hSSFRow.getCell(53));
                        string        str31         = notNull(hSSFRow.getCell(54));
                        string        str32         = notNull(hSSFRow.getCell(55));
                        string        str33         = notNull(hSSFRow.getCell(56));
                        string        str34         = notNull(hSSFRow.getCell(57));
                        string        str35         = notNull(hSSFRow.getCell(58));
                        string        str36         = notNull(hSSFRow.getCell(59));
                        AssemblyTable assemblyTable = BlankResourceInitializer.createBlankAssembly(null);
                        assemblyTable.ItemCode = str6;
                        assemblyTable.PublishedRevisionCode = str6;
                        assemblyTable.Title        = str7;
                        assemblyTable.Unit         = str8;
                        assemblyTable.Currency     = "USD";
                        assemblyTable.Country      = "US";
                        assemblyTable.Quantity     = bigDecimal1;
                        assemblyTable.LastUpdate   = this.lastUpdate;
                        assemblyTable.Description  = "";
                        assemblyTable.LastUpdate   = this.lastUpdate;
                        assemblyTable.CreateDate   = this.lastUpdate;
                        assemblyTable.CreateUserId = "admin";
                        assemblyTable.EditorId     = "admin";
                        if (groupCodeTable != null)
                        {
                            assemblyTable.GroupCode = groupCodeTable.ToString();
                        }
                        assemblyTable.AssemblyEquipmentSet     = new HashSet <object>();
                        assemblyTable.AssemblySubcontractorSet = new HashSet <object>();
                        assemblyTable.AssemblyLaborSet         = new HashSet <object>();
                        assemblyTable.AssemblyMaterialSet      = new HashSet <object>();
                        assemblyTable.AssemblyConsumableSet    = new HashSet <object>();
                        long?long     = (long?)paramSession.save(assemblyTable.clone());
                        assemblyTable = (AssemblyTable)paramSession.load(typeof(AssemblyTable), long);
                        if (!StringUtils.isNullOrBlank(str9))
                        {
                            LaborTable laborTable = (LaborTable)this.laborCache[str9];
                            if (laborTable == null)
                            {
                                laborTable              = BlankResourceInitializer.createBlankLabor(null);
                                laborTable.Title        = str9;
                                laborTable.Unit         = "HOUR";
                                laborTable.Rate         = bigDecimal5;
                                laborTable.IKA          = BigDecimalMath.ZERO;
                                laborTable.Currency     = "USD";
                                laborTable.Country      = "US";
                                laborTable.LastUpdate   = this.lastUpdate;
                                laborTable.CreateDate   = this.lastUpdate;
                                laborTable.CreateUserId = "admin";
                                laborTable.EditorId     = "admin";
                                long                  = (long?)paramSession.save(laborTable.clone());
                                laborTable.Id         = long;
                                this.laborCache[str9] = laborTable;
                            }
                            else
                            {
                                laborTable = (LaborTable)paramSession.load(typeof(LaborTable), laborTable.Id);
                            }
                            if (BigDecimalMath.cmp(bigDecimal4, BigDecimalMath.ZERO) <= 0 && BigDecimalMath.cmp(bigDecimal2, BigDecimalMath.ZERO) > 0)
                            {
                                bigDecimal4 = BigDecimalMath.div(BigDecimalMath.ONE, bigDecimal2);
                            }
                            laborTable = (LaborTable)paramSession.load(typeof(LaborTable), laborTable.Id);
                            AssemblyLaborTable assemblyLaborTable = new AssemblyLaborTable();
                            assemblyLaborTable.Factor1                     = BigDecimalMath.ONE;
                            assemblyLaborTable.Factor2                     = BigDecimalMath.ONE;
                            assemblyLaborTable.Factor3                     = BigDecimalMath.ONE;
                            assemblyLaborTable.ExchangeRate                = BigDecimalMath.ONE;
                            assemblyLaborTable.QuantityPerUnit             = bigDecimal4;
                            assemblyLaborTable.QuantityPerUnitFormula      = "";
                            assemblyLaborTable.QuantityPerUnitFormulaState = ResourceToAssignmentTable.QTYPUFORM_NOFORMULA;
                            assemblyLaborTable.LocalFactor                 = BigDecimalMath.ONE;
                            assemblyLaborTable.LocalCountry                = "";
                            assemblyLaborTable.LocalStateProvince          = "";
                            assemblyLaborTable.LastUpdate                  = assemblyTable.LastUpdate;
                            long = (long?)paramSession.save(assemblyLaborTable);
                            assemblyLaborTable.AssemblyLaborId = long;
                            assemblyTable.AssemblyLaborSet.Add(assemblyLaborTable);
                            paramSession.saveOrUpdate(assemblyTable);
                            assemblyLaborTable.LaborTable    = laborTable;
                            assemblyLaborTable.AssemblyTable = assemblyTable;
                            paramSession.saveOrUpdate(assemblyLaborTable);
                        }
                        if (bigDecimal14 != null && BigDecimalMath.cmp(bigDecimal14, BigDecimalMath.ZERO) > 0)
                        {
                            if (bigDecimal11 != null && BigDecimalMath.cmp(bigDecimal11, BigDecimalMath.ZERO) > 0)
                            {
                                decimal bigDecimal = bigDecimal13;
                                if (BigDecimalMath.cmp(bigDecimal, BigDecimalMath.ZERO) <= 0 && BigDecimalMath.cmp(bigDecimal11, BigDecimalMath.ZERO) > 0)
                                {
                                    bigDecimal = BigDecimalMath.div(BigDecimalMath.ONE, bigDecimal11);
                                }
                                if (str8.Equals("DAY"))
                                {
                                    bigDecimal14 = BigDecimalMath.mult(bigDecimal14, BigDecimalMath.div(BigDecimalMath.ONE, HOURS_OF_DAY));
                                }
                                else if (str8.Equals("WEEK") || str8.Equals("WK"))
                                {
                                    bigDecimal14 = BigDecimalMath.mult(bigDecimal14, BigDecimalMath.div(BigDecimalMath.ONE, HOURS_OF_WEEK));
                                }
                                else if (str8.Equals("MONTH") || str8.Equals("MO"))
                                {
                                    bigDecimal14 = BigDecimalMath.mult(bigDecimal14, BigDecimalMath.div(BigDecimalMath.ONE, HOURS_OF_MONTH));
                                }
                                if (str20.Equals("WEEK"))
                                {
                                    bigDecimal = BigDecimalMath.mult(bigDecimal, HOURS_OF_WEEK);
                                }
                                else if (str20.Equals("MO") || str20.Equals("MONTH"))
                                {
                                    bigDecimal = BigDecimalMath.mult(bigDecimal, HOURS_OF_MONTH);
                                }
                                else if (str20.Equals("DAY"))
                                {
                                    bigDecimal = BigDecimalMath.mult(bigDecimal, HOURS_OF_DAY);
                                }
                                EquipmentTable equipmentTable = BlankResourceInitializer.createBlankEquipment(assemblyTable);
                                equipmentTable.Title           = assemblyTable.Title;
                                equipmentTable.Unit            = str20;
                                equipmentTable.ReservationRate = bigDecimal14;
                                equipmentTable.Currency        = "USD";
                                equipmentTable.EditorId        = "admin";
                                equipmentTable.Country         = "US";
                                equipmentTable.LastUpdate      = this.lastUpdate;
                                equipmentTable.CreateDate      = this.lastUpdate;
                                equipmentTable.CreateUserId    = "admin";
                                equipmentTable.EditorId        = "admin";
                                long = (long?)paramSession.save(equipmentTable.clone());
                                equipmentTable.Id = long;
                                equipmentTable    = (EquipmentTable)paramSession.load(typeof(EquipmentTable), long);
                                AssemblyEquipmentTable assemblyEquipmentTable = new AssemblyEquipmentTable();
                                assemblyEquipmentTable.Factor1                     = BigDecimalMath.ONE;
                                assemblyEquipmentTable.Factor2                     = BigDecimalMath.ONE;
                                assemblyEquipmentTable.Factor3                     = BigDecimalMath.ONE;
                                assemblyEquipmentTable.ExchangeRate                = BigDecimalMath.ONE;
                                assemblyEquipmentTable.QuantityPerUnit             = bigDecimal;
                                assemblyEquipmentTable.QuantityPerUnitFormula      = "";
                                assemblyEquipmentTable.QuantityPerUnitFormulaState = ResourceToAssignmentTable.QTYPUFORM_NOFORMULA;
                                assemblyEquipmentTable.LocalFactor                 = BigDecimalMath.ONE;
                                assemblyEquipmentTable.LocalCountry                = "";
                                assemblyEquipmentTable.LocalStateProvince          = "";
                                assemblyEquipmentTable.EnergyPrice                 = BigDecimalMath.ZERO;
                                assemblyEquipmentTable.FuelRate                    = BigDecimalMath.ZERO;
                                assemblyEquipmentTable.LastUpdate                  = assemblyTable.LastUpdate;
                                long = (long?)paramSession.save(assemblyEquipmentTable);
                                assemblyEquipmentTable.AssemblyEquipmentId = long;
                                assemblyTable.AssemblyEquipmentSet.Add(assemblyEquipmentTable);
                                paramSession.saveOrUpdate(assemblyTable);
                                assemblyEquipmentTable.EquipmentTable = equipmentTable;
                                assemblyEquipmentTable.AssemblyTable  = assemblyTable;
                                paramSession.saveOrUpdate(assemblyEquipmentTable);
                            }
                            else
                            {
                                createSubcontractor(paramSession, assemblyTable, "Equipment: " + assemblyTable.Title, bigDecimal14, str20, bigDecimal13);
                            }
                        }
                        if (bigDecimal9 != null && BigDecimalMath.cmp(bigDecimal9, BigDecimalMath.ZERO) > 0)
                        {
                            MaterialTable materialTable = BlankResourceInitializer.createBlankMaterial(assemblyTable);
                            materialTable.Title        = assemblyTable.Title;
                            materialTable.Unit         = str16;
                            materialTable.Rate         = bigDecimal9;
                            materialTable.Currency     = "USD";
                            materialTable.EditorId     = "admin";
                            materialTable.Country      = "US";
                            materialTable.LastUpdate   = this.lastUpdate;
                            materialTable.CreateDate   = this.lastUpdate;
                            materialTable.CreateUserId = "admin";
                            materialTable.EditorId     = "admin";
                            long             = (long?)paramSession.save(materialTable.clone());
                            materialTable.Id = long;
                            materialTable    = (MaterialTable)paramSession.load(typeof(MaterialTable), long);
                            AssemblyMaterialTable assemblyMaterialTable = new AssemblyMaterialTable();
                            assemblyMaterialTable.Factor1                     = BigDecimalMath.ONE;
                            assemblyMaterialTable.Factor2                     = BigDecimalMath.ONE;
                            assemblyMaterialTable.Factor3                     = BigDecimalMath.ONE;
                            assemblyMaterialTable.ExchangeRate                = BigDecimalMath.ONE;
                            assemblyMaterialTable.QuantityPerUnit             = bigDecimal8;
                            assemblyMaterialTable.QuantityPerUnitFormula      = "";
                            assemblyMaterialTable.QuantityPerUnitFormulaState = ResourceToAssignmentTable.QTYPUFORM_NOFORMULA;
                            assemblyMaterialTable.LocalFactor                 = BigDecimalMath.ONE;
                            assemblyMaterialTable.LocalCountry                = "";
                            assemblyMaterialTable.LocalStateProvince          = "";
                            assemblyMaterialTable.LastUpdate                  = assemblyTable.LastUpdate;
                            long = (long?)paramSession.save(assemblyMaterialTable);
                            assemblyMaterialTable.AssemblyMaterialId = long;
                            assemblyTable.AssemblyMaterialSet.Add(assemblyMaterialTable);
                            paramSession.saveOrUpdate(assemblyTable);
                            assemblyMaterialTable.MaterialTable = materialTable;
                            assemblyMaterialTable.AssemblyTable = assemblyTable;
                            paramSession.saveOrUpdate(assemblyMaterialTable);
                        }
                        if (bigDecimal24 != null && BigDecimalMath.cmp(bigDecimal24, BigDecimalMath.ZERO) > 0)
                        {
                            createSubcontractor(paramSession, assemblyTable, assemblyTable.Title, bigDecimal24, str28, bigDecimal23);
                        }
                        if (bigDecimal19 != null && BigDecimalMath.cmp(bigDecimal19, BigDecimalMath.ZERO) > 0)
                        {
                            ConsumableTable consumableTable = BlankResourceInitializer.createBlankConsumable(assemblyTable);
                            consumableTable.Title        = assemblyTable.Title;
                            consumableTable.Unit         = str24;
                            consumableTable.Rate         = bigDecimal19;
                            consumableTable.Currency     = "USD";
                            consumableTable.EditorId     = "admin";
                            consumableTable.Country      = "US";
                            consumableTable.LastUpdate   = this.lastUpdate;
                            consumableTable.CreateDate   = this.lastUpdate;
                            consumableTable.CreateUserId = "admin";
                            consumableTable.EditorId     = "admin";
                            long = (long?)paramSession.save(consumableTable.clone());
                            consumableTable.Id = long;
                            consumableTable    = (ConsumableTable)paramSession.load(typeof(ConsumableTable), long);
                            AssemblyConsumableTable assemblyConsumableTable = new AssemblyConsumableTable();
                            assemblyConsumableTable.Factor1                     = BigDecimalMath.ONE;
                            assemblyConsumableTable.Factor2                     = BigDecimalMath.ONE;
                            assemblyConsumableTable.Factor3                     = BigDecimalMath.ONE;
                            assemblyConsumableTable.ExchangeRate                = BigDecimalMath.ONE;
                            assemblyConsumableTable.QuantityPerUnit             = bigDecimal18;
                            assemblyConsumableTable.QuantityPerUnitFormula      = "";
                            assemblyConsumableTable.QuantityPerUnitFormulaState = ResourceToAssignmentTable.QTYPUFORM_NOFORMULA;
                            assemblyConsumableTable.LocalFactor                 = BigDecimalMath.ONE;
                            assemblyConsumableTable.LocalCountry                = "";
                            assemblyConsumableTable.LocalStateProvince          = "";
                            assemblyConsumableTable.LastUpdate                  = assemblyTable.LastUpdate;
                            long = (long?)paramSession.save(assemblyConsumableTable);
                            assemblyConsumableTable.AssemblyConsumableId = long;
                            assemblyTable.AssemblyConsumableSet.Add(assemblyConsumableTable);
                            paramSession.saveOrUpdate(assemblyTable);
                            assemblyConsumableTable.ConsumableTable = consumableTable;
                            assemblyConsumableTable.AssemblyTable   = assemblyTable;
                            paramSession.saveOrUpdate(assemblyConsumableTable);
                        }
                        if (DatabaseDBUtil.LocalCommunication)
                        {
                            assemblyTable.recalculate();
                            paramSession.saveOrUpdate(assemblyTable);
                        }
                    }
                }
            }
            if (hSSFWorkbook != null)
            {
                hSSFWorkbook.close();
            }
        }
コード例 #4
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void loadCSI95(org.hibernate.Session paramSession, String paramString) throws Exception
        private void loadCSI95(Session paramSession, string paramString)
        {
            Console.WriteLine("\n\n\n\nLoading CSI 1995");
            POIFSFileSystem pOIFSFileSystem = new POIFSFileSystem(new FileStream(paramString, FileMode.Open, FileAccess.Read));
            HSSFWorkbook    hSSFWorkbook    = new HSSFWorkbook(pOIFSFileSystem);

            this.o_evaluator = hSSFWorkbook.CreationHelper.createFormulaEvaluator();
            HSSFSheet hSSFSheet = hSSFWorkbook.getSheetAt(0);
            int       i         = getRealNumberOfRows(hSSFSheet);

            for (int j = 1; j < i; j++)
            {
                string str4;
                string str3;
                string str2;
                if (j % this.rowsToCommit == 0)
                {
                    paramSession.Transaction.commit();
                    paramSession.Transaction.begin();
                    Console.WriteLine("Processing next " + this.rowsToCommit + "...");
                }
                HSSFRow hSSFRow = hSSFSheet.getRow(j);
                string  str1    = notNull(hSSFRow.getCell(1));
                if (StringUtils.isEmpty(str1))
                {
                    string str = notNull(hSSFRow.getCell(3));
                    int    k   = str.IndexOf(" -- ", StringComparison.Ordinal);
                    if (k == -1)
                    {
                        continue;
                    }
                    str2 = str.Substring(0, k);
                    str2 = StringUtils.replaceAll(str2, "Division ", "");
                    if (str2.Length == 1)
                    {
                        str2 = "0" + str2;
                    }
                    str3 = StringUtils.replaceAll(str, " -- ", " ");
                    str4 = str2 + "000";
                }
                else if (str1.Equals("00"))
                {
                    str2 = str4 = notNull(hSSFRow.getCell(2));
                    str3 = notNull(hSSFRow.getCell(4));
                    str2 = str4.Substring(0, 2) + "." + str4.Substring(2, 1);
                    str3 = StringUtils.replaceAll(str3, " - ", " ");
                }
                else
                {
                    str2 = str4 = notNull(hSSFRow.getCell(2));
                    str3 = notNull(hSSFRow.getCell(5));
                    string str = str2.Substring(2, 1);
                    str  = str + ".";
                    str2 = str4.Substring(0, 2) + "." + str + str4.Substring(3, 2);
                    str3 = StringUtils.replaceAll(str3, " - ", " ");
                }
                GroupCodeTable groupCodeTable = (GroupCodeTable)addGroupCode1(str2, str3, str4);
                long?long = (long?)paramSession.save(groupCodeTable);
                groupCodeTable.GroupCodeId = long;
                this.csi95Map[str4]        = groupCodeTable.ToString();
                Console.WriteLine(str2 + " = " + str4 + " = " + str3);
                continue;
            }
        }