Beispiel #1
0
        // Loads an .nzb file
        public static FileCollection loadFile(string filename)
        {
            // Loadtime measuring
            Performance.Stopwatch sw = new Performance.Stopwatch();
            sw.Start();

            XmlDocument document = new XmlDocument();
            FileStream stream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

            // Inits xmlreader with custom resolver for instant dtd file lookup
            XmlReaderSettings settings = new XmlReaderSettings();
            settings.ProhibitDtd = false;
            settings.XmlResolver = new XmlFileResolver();

            // Create new FIleCOllection object

            FileCollection collection = new FileCollection(getPrettyFilename(filename));

            // Parse file into XmlDocument
            document.Load(XmlReader.Create(stream, settings));
            stream.Close();

            List<FileJob> files = ParseXML(document, collection);
            collection.files = files;

            // Calculate collection size
            collection.CalculateTotalSize();
            // Loadtime measuring
            sw.Stop();
            Logging.Instance.Log("Loading {0}. Took {1}ms", filename, sw.GetElapsedTimeSpan().TotalMilliseconds);
            return collection;
        }
Beispiel #2
0
        public NNTPConnection(int id, NewsServer serverInfo, QueueHandler handler)
        {
            this.id = id;
            this.serverInfo = serverInfo;
            this.handler = handler;
            keepAlive = true;
            sw = new Performance.Stopwatch();

            // Register connection in SpeedMonitor
            SpeedMonitor.Instance.RegisterConnection(this);

            ThreadStart job = new ThreadStart(Run);
            Thread thread = new Thread(job);
            thread.IsBackground = true;
            thread.Start();
        }
        private bool saveOrUpdateDocument(Document.Document source)
        {
            //Performance measurement
            var sw = new Performance.Stopwatch("saveOrUpdateDocument");
            sw.Start();
            logger.Debug("Receiving SaveOrUpdate for " + source.DocumentType + " with ID " + source.DocumentID);

            if (!DocumentDB.AncestorsAndSelf("Documents").Any())
                DocumentDB.Add(new XElement("Documents"));

            if (DocumentDB.Elements(source.DocumentType).Any(x => x.Element("ID").Value == source.DocumentID))
            {
                logger.Debug("Updating " + source.DocumentType + " with ID " + source.DocumentID);
                DocumentDB.Elements(source.DocumentType).Single(x => x.Element("ID").Value == source.DocumentID).ReplaceWith(source.GetXElement());
            }
            else
            {
                logger.Debug("Adding " + source.DocumentType + " with ID " + source.DocumentID);
                DocumentDB.Add(source.GetXElement());
            }
            try { File.WriteAllText(DatabasePath + CurrentCompany.CompanyID + "\\Documents.xml", DocumentDB.ToString()); }
            catch (Exception e) { logger.Fatal("Error writing Document to " + DatabasePath + CurrentCompany.CompanyID + "\\Documents.xml", e); return false; }
            sw.Stop();
            logger.Info(sw.Result());

            return true;
        }
        private IEnumerable<Interfaces.IXMLStorageable> allStorageableItems(Interfaces.IXMLStorageable referenceStorageable)
        {
            var sw = new Performance.Stopwatch("allStorageableItems: " + referenceStorageable.XElementName);
            sw.Start();

            var list = new ObservableCollection<Interfaces.IXMLStorageable>();

            var isregistered = from registered in RegisteredAdditionalDBs where registered.XElementName == referenceStorageable.XElementName select registered;
            if (isregistered.Count() == 0)
                return list;

            XElement db = (from dbs in OtherDBs where dbs.Name == (referenceStorageable.XElementName + "s") select dbs).First();

            if (!db.AncestorsAndSelf(referenceStorageable.XElementName + "s").Any())
                return list;

            var itemlist = db.AncestorsAndSelf(referenceStorageable.XElementName + "s").Elements(referenceStorageable.XElementName);
            foreach (XElement item in itemlist)
            {
                try
                {
                    var tempitem = referenceStorageable.GetNewInstance();
                    tempitem.ParseFromXElement(item);
                    list.Add(tempitem);
                }
                catch (Exception e) { logger.Fatal("Error parsing the element", e); }
            }
            sw.Stop();
            logger.Info(sw.Result(list.Count()));
            return list;
        }
        private Customers.Customer getCustomer(string CustomerID)
        {
            if (!CustomerDB.Elements("Customer").Any())
                return new Customers.Customer();

            if (CustomerDB.Elements("Customer").Any(x => x.Element("CustomerID").Value == CustomerID))
            {
                var sw = new Performance.Stopwatch("GetCustomer (" + CustomerID + ")");
                sw.Start();
                var temp = new Customers.Customer();
                var xitem = CustomerDB.Elements("Customer").Single(x => x.Element("CustomerID").Value == CustomerID);
                temp.ParseFromXElement(xitem);
                if (paymentMethodesList().Any(x => x.Name == xitem.Element("DefaultPaymentMethode").Value))
                    temp.DefaultPaymentMethode = paymentMethodesList().First(x => x.Name == xitem.Element("DefaultPaymentMethode").Value);
                sw.Stop();
                sw.PrintResultToConsole();
                logger.Trace(sw.Result());

                return temp;
            }
            else
                return new Customers.Customer();
        }
        private ObservableCollection<Document.PreviewDocument> documentsInInterval(DateTime IntervalStart, DateTime IntervalEnd, string DocumentType)
        {
            var sw = new Performance.Stopwatch("documentsInInterval");
            sw.Start();

            var output = new ObservableCollection<Document.PreviewDocument>();

            if (!DocumentDB.AncestorsAndSelf("Documents").Any())
                return output;

            if (!String.IsNullOrEmpty(DocumentType))
            {
                var list = from document in DocumentDB.Elements() where document.Name == DocumentType && IntervalStart <= DateTime.Parse(document.Element("Date").Value) && IntervalEnd >= DateTime.Parse(document.Element("Date").Value) select document;
                foreach (XElement item in list)
                {
                    dynamic temp = new Document.PreviewDocument(item.Name.ToString());
                    temp.DocumentID = item.Element("ID").Value;
                    temp.Customer = item.Element("CustomerPreview").Value;
                    temp.Date = DateTime.Parse(item.Element("Date").Value);

                    foreach (Interfaces.DocumentParser parser in AdditionalPreviewParsers.Where(x => x.DocumentType == item.Name.ToString()))
                    { var result = parser.ParseAdditionalPreviewData(ref temp, item); }

                    output.Add(temp);
                }
            }
            else 
            {
                var list = from document in DocumentDB.Elements() where IntervalStart <= DateTime.Parse(document.Element("Date").Value) && IntervalEnd >= DateTime.Parse(document.Element("Date").Value) select document;
                foreach (XElement item in list)
                {
                    dynamic temp = new Document.PreviewDocument(item.Name.ToString());
                    temp.DocumentID = item.Element("ID").Value;
                    temp.Customer = item.Element("PreviewCustomer").Value;
                    temp.Date = DateTime.Parse(item.Element("Date").Value);

                    foreach (Interfaces.DocumentParser parser in AdditionalPreviewParsers.Where(x => x.DocumentType == item.Name.ToString()))
                    { var result = parser.ParseAdditionalPreviewData(ref temp, item); }

                    output.Add(temp);
                }
            }

            logger.Info(sw.Result(output.Count));
            return output;
        }
        private bool saveOrUpdateCustomer(IEnumerable<Customers.Customer> source)
        {
            var sw = new Performance.Stopwatch("SaveOrUpdateCustomer");
            sw.Start();
            if (!CustomerDB.AncestorsAndSelf("Customers").Any())
                CustomerDB.Add(new XElement("Customers"));

            foreach (var item in source)
            {
                if (CustomerDB.Elements("Customer").Any(x => x.Element("CustomerID").Value == item.CustomerID))
                    CustomerDB.Elements("Customer").Single(x => x.Element("CustomerID").Value == item.CustomerID).ReplaceWith(item.GetXElement());
                else
                    CustomerDB.Add(item.GetXElement());
            }
            
            try { File.WriteAllText(DatabasePath + CurrentCompany.CompanyID + "\\Customers.xml", CustomerDB.ToString()); }
            catch (Exception e) { logger.Fatal("Error writing article to " + DatabasePath + CurrentCompany.CompanyID + "\\Customers.xml", e); return false; }
            sw.Stop();
            logger.Info(sw.Result(source.Count()));
            return true;
        }
        private IEnumerable<Customers.PreviewCustomer> GetAllCustomers()
        {
            var sw = new Performance.Stopwatch("GetAllCustomers");
            sw.Start();

            logger.Debug("Start getting customer list");
            var templist = new ObservableCollection<Customers.PreviewCustomer>();
            if (!CustomerDB.Elements("Customer").Any())
                return templist;

            var itemlist = CustomerDB.Elements("Customer");
            foreach (XElement item in itemlist)
            {
                try
                {
                    dynamic tempitem = new Customers.PreviewCustomer();
                    tempitem.CustomerID = item.Element("CustomerID").Value;
                    tempitem.DisplayName = item.Element("DisplayName").Value;
                    var address = new Utils.Address();
                    address.ParseFromXElement(item.Element("MainAddress").Element(address.XElementName));
                    tempitem.Address = address.OneLineString;
                    templist.Add(tempitem);
                }
                catch (Exception e) { logger.Fatal("Error parsing the in 'GetAllCustomers': " + item.ToString(), e); }
            }
            sw.Stop();
            logger.Info(sw.Result(templist.Count));

            return templist;
        }
        private Articles.Article getArticle(string ArticleID)
        {
            if (!ArticleDB.Elements("Article").Any())
                return new Articles.Article();

            if (ArticleDB.Elements("Article").Any(x => x.Element("ArticleID").Value == ArticleID))
            {
                var sw = new Performance.Stopwatch("GetArticle (" + ArticleID + ")");
                sw.Start();
                var temp = new Core.Articles.Article();
                var xitem = ArticleDB.Elements("Article").Single(x => x.Element("ArticleID").Value == ArticleID);
                temp.ParseFromXElement(xitem);
                temp.TaxClass = TaxClassesList().SingleOrDefault(x => x.Name == xitem.Element("TaxClass").Value);
                temp.ArticleUnit = ArticleUnitsList().SingleOrDefault(x => x.Name == xitem.Element("ArticleUnit").Value);

                sw.Stop();
                sw.PrintResultToConsole();
                logger.Trace(sw.Result());

                return temp;
            }
            else
                return new Articles.Article();
        }
        private bool saveOrUpdateArticle(Articles.Article source)
        {
            var sw = new Performance.Stopwatch("saveOrUpdateArticle");
            sw.Start();
            if (!ArticleDB.AncestorsAndSelf("Articles").Any())
                ArticleDB.Add(new XElement("Articles"));

            if (ArticleDB.Elements("Article").Any(x => x.Element("ArticleID").Value == source.ArticleID))
                ArticleDB.Elements("Article").Single(x => x.Element("ArticleID").Value == source.ArticleID).ReplaceWith(source.GetXElement());
            else
                ArticleDB.Add(source.GetXElement());

            try { File.WriteAllText(DatabasePath + CurrentCompany.CompanyID + "\\Articles.xml", ArticleDB.ToString()); }
            catch (Exception e) { logger.Fatal("Error writing article to " + DatabasePath + CurrentCompany.CompanyID + "\\Articles.xml", e); return false; }
            sw.Stop();
            logger.Info(sw.Result());
            return true;
        }
        private IEnumerable<Articles.PreviewArticle> GetAllArticles()
        {
            var sw = new Performance.Stopwatch("GetAllArticles");
            sw.Start();

            logger.Debug("Start getting article list");
            var templist = new ObservableCollection<Articles.PreviewArticle>();
            if (!ArticleDB.Elements("Article").Any())
                return templist;

            var itemlist = ArticleDB.Elements("Article");
            foreach (XElement item in itemlist)
            {
                try
                {
                    dynamic tempitem = new Articles.PreviewArticle();
                    tempitem.ArticleID = item.Element("ArticleID").Value;
                    tempitem.ArticleDescription = item.Element("ArticleDescription").Value;
                    tempitem.ArticlePrice.ParseFromXElement(item.Element("Price1").Element("PriceGroup").Element("Money"));
                    tempitem.ArticleUnit = item.Element("ArticleUnit").Value;
                    templist.Add(tempitem);
                }
                catch (Exception e) { logger.Fatal("Error parsing the in 'GetAllArticles': "+ item.ToString(), e); }
            }
            sw.Stop();
            logger.Info(sw.Result(templist.Count));

            return templist;
        }
        private bool saveOrUpdateStorageableItem(Interfaces.IXMLStorageable StorageableItem)
        {
            var sw = new Performance.Stopwatch("saveOrUpdateStorageableItem: " + StorageableItem.XElementName + ", " + StorageableItem.ID);
            sw.Start();

            var isregistered = from registered in RegisteredAdditionalDBs where registered.XElementName == StorageableItem.XElementName select registered;
            if (isregistered.Count() == 0)
                return false;

            XElement db = (from dbs in OtherDBs where dbs.Name == (StorageableItem.XElementName + "s") select dbs).First();

            if (!db.AncestorsAndSelf(StorageableItem.XElementName + "s").Any())
                db.Add(new XElement(StorageableItem.XElementName + "s"));

            try
            {
                if (db.Elements(StorageableItem.XElementName).Any(x => x.Element(StorageableItem.IDFieldName).Value == StorageableItem.ID))
                    db.Elements(StorageableItem.XElementName).Single(x => x.Element(StorageableItem.IDFieldName).Value == StorageableItem.ID).ReplaceWith(StorageableItem.GetXElement());
                else
                    db.Add(StorageableItem.GetXElement());
            }
            catch (Exception e)
            {
                logger.Fatal("Error saving " + StorageableItem.XElementName, e);
            }

            try { File.WriteAllText(DatabasePath + CurrentCompany.CompanyID + "\\" + StorageableItem.XElementName + "s.xml", db.ToString()); }
            catch (Exception e) { logger.Fatal("Error writing " + StorageableItem.XElementName + " to " + DatabasePath + CurrentCompany.CompanyID + "\\" + StorageableItem.XElementName + "s.xml", e); }

            sw.Stop();
            logger.Info(sw.Result());
            return true;
        }
        private bool storageableItemExists(Interfaces.IXMLStorageable referenceStorageable)
        {
            var sw = new Performance.Stopwatch("storageableItemExists: " + referenceStorageable.XElementName);
            sw.Start();

            var isregistered = from registered in RegisteredAdditionalDBs where registered.XElementName == referenceStorageable.XElementName select registered;
            if (isregistered.Count() == 0)
                return false;

            XElement db = (from dbs in OtherDBs where dbs.Name == (referenceStorageable.XElementName + "s") select dbs).First();

            if (!db.AncestorsAndSelf(referenceStorageable.XElementName + "s").Any())
                db.Add(new XElement(referenceStorageable.XElementName + "s"));

            if (db.Elements(referenceStorageable.XElementName).Any(x => x.Element(referenceStorageable.IDFieldName).Value == referenceStorageable.ID))
            {
                sw.Stop();
                logger.Info(sw.Result());
                return true;
            }
            else
            {
                sw.Stop();
                logger.Info(sw.Result());
                return false;
            }
        }