public static async Task PushExoDataToZudello()
        {
            string Token = ZudelloLogin.Login();



            SQLCredentials           ConnectionString = new SQLCredentials();
            Dictionary <int, string> Connection       = ConnectionString.ConnectionStringBuilder();


            /****
             *
             * Add threading into here for the foreach loop
             * will need to chunk based on amount of connections
             */

            //get the query from mappings table
            Dictionary <int, Zmapping> MappingsBody     = getBody();
            int                    numberOfLogicalCores = Environment.ProcessorCount;
            List <Thread>          threads        = new List <Thread>(numberOfLogicalCores);
            int                    sizeOfOneChunk = (MappingsBody.Count / numberOfLogicalCores) + 1;
            ConcurrentBag <string> cb             = new ConcurrentBag <string>();
            ConcurrentBag <int>    cbMaps         = new ConcurrentBag <int>();

            for (int i = 0; i < numberOfLogicalCores; i++)
            {
                int ab  = i;
                var thr = new Thread(

                    () =>
                {
                    try
                    {
                        int count = 0;
                        Dictionary <int, Zmapping> MappingsChunked = MappingsBody.Skip(ab * sizeOfOneChunk)
                                                                     .Take(sizeOfOneChunk).ToDictionary(p => p.Key, p => p.Value);


                        foreach (var Mappings in MappingsChunked)
                        {
                            bool isXMl = true;
                            //Get the SQL statement
                            string mySql = Mappings.Value.Body;
                            //Get the Mappings
                            dynamic zudelloObject = Mappings.Value;


                            string SQLQuery = ExoTools.RenderToSql(mySql, zudelloObject);

#warning make this in config also for process method


                            string cmd = SQLQuery;

                            //Open SQL connection and run the SQL query


                            //Get connection details by Key ID
                            SqlConnection con        = new SqlConnection(Connection[Mappings.Value.connection_id]);
                            SqlCommand SelectCommand = new SqlCommand(cmd, con);
                            // SqlDataReader myreader;
                            con.Open();

                            if (cmd.ToLower().Contains("for xml"))
                            {
                                isXMl = true;
                            }

                            if (String.IsNullOrEmpty(cmd))
                            {
                                continue;
                            }
                            var jsonResult = new StringBuilder();
                            var xmlConvert = new StringBuilder();
                            //SelectCommand.CommandText = cmd;
                            var myreader = SelectCommand.ExecuteReader();

                            if (!myreader.HasRows)
                            {
                                //if there is no data then close connection and next loop
                                con.Close();
                                con.Dispose();
                                continue;
                            }
                            else
                            {
                                while (myreader.Read())
                                {
                                    jsonResult.Append(myreader.GetValue(0).ToString());
                                }

                                //Console.WriteLine(jsonResult);

                                dynamic obj         = "";
                                string ConvertedXml = "";
                                if (isXMl == true)
                                {
                                    ConvertedXml = ExoTools.ZudelloXMLConverter(jsonResult.ToString());

                                    //  string ConvertedXml = ExoTools.ZudelloXMLConverter(jsonResult.ToString());
                                    obj = JsonConvert.DeserializeObject <ExpandoObject>(ConvertedXml);
                                }
                                else
                                {
                                    obj = JsonConvert.DeserializeObject <ExpandoObject>(jsonResult.ToString());
                                }
                                foreach (var ObjectType in obj)

                                {
                                    //not sure why .Value is causing error but not affecting build
                                    foreach (var dataValues in ObjectType.Value)
                                    {
                                        string data = "";
                                        if (isXMl == true)
                                        {
                                            data = JsonConvert.SerializeObject(dataValues);
                                        }
                                        else
                                        {
                                            MyQueueObject dataWrapper = new MyQueueObject();
                                            dataWrapper.data          = dataValues;
                                            data = JsonConvert.SerializeObject(dataWrapper);
                                        }

                                        // add to concurrent bag
                                        cb.Add(data);
                                        count++;
                                        //  Console.WriteLine(data);
                                    }
                                }

                                cbMaps.Add(Mappings.Value.Id);
                            }


                            con.Close();
                            con.Dispose();
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                }
                    );

                threads.Add(thr);
            }


            foreach (var thread in threads)
            {
                thread.Start();
            }

            foreach (var thread in threads)
            {
                thread.Join();
            }

            threads.Clear();


            int sizeOfOneChunkQueue = (cb.Count / numberOfLogicalCores) + 1;

            for (int x = 0; x < numberOfLogicalCores; x++)
            {
                int abx            = x;
                var SendToQueuethr = new Thread(

                    () =>
                {
                    try
                    {
                        int count = 0;
                        List <string> queuedBag = cb.Skip(abx * sizeOfOneChunkQueue)
                                                  .Take(sizeOfOneChunkQueue).ToList();


                        foreach (var Mappings in queuedBag)
                        {
                            Console.WriteLine(ZudelloLogin.SendToZudelloQueue(Token, Mappings));
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                });
                threads.Add(SendToQueuethr);
            }

            foreach (var qthread in threads)
            {
                qthread.Start();
            }

            foreach (var qthread in threads)
            {
                qthread.Join();
            }



            /*
             *              List<Task> bagConsumeTasks = new List<Task>();
             *          int itemsInBag = 0;
             *          while (!cb.IsEmpty)
             *          {
             *              bagConsumeTasks.Add(Task.Run(() =>
             *              {
             *                  string item;
             *                  if (cb.TryTake(out item))
             *                  {
             *
             *                      Console.WriteLine(ZudelloLogin.SendToZudelloQueue(Token, item));
             *                      itemsInBag++;
             *                  }
             *              }));
             *          } */

            //   Task.WaitAll(bagConsumeTasks.ToArray());

            foreach (int id in cbMaps)
            {
                using (var db = new ZudelloContext())
                {
                    var lastSync = db.Zlastsync.Where(s => s.MappingId == id).FirstOrDefault();

                    lastSync.LastSync = DateTime.Now.ToString();

                    db.SaveChanges();
                    db.DisposeAsync();
                }
            }
        }
示例#2
0
        public static ProccessResponse ProcessMethod(dynamic queueData)
        {
            ProccessResponse pr = new ProccessResponse();


            //Get list of Databases
            SQLCredentials           ConnectionString = new SQLCredentials();
            Dictionary <int, string> Connection       = ConnectionString.ConnectionStringBuilder();

            Console.WriteLine(queueData.queue.Id.ToString());
            dynamic zudelloObject = "";

            try
            {
                zudelloObject = JsonConvert.DeserializeObject <ExpandoObject>(queueData.queue.Body);
                string order = queueData.map.ProcessOrder.ToString();

                //Created at
                string obj     = queueData.map.DocType.ToString();
                string uuid    = "";//zudelloObject.invoiceUUID.ToString();
                string queueID = queueData.queue.Id.ToString();

                //Generate the insert Query
                string SQLQuery = ExoTools.RenderToSql(queueData.map.Body, zudelloObject);


                if (zudelloObject.uuid != null)
                {
                    pr.SyncHistryUuid = zudelloObject.uuid;
                    pr.Team           = zudelloObject.document.teamUuid;
                }

                string cmd = SQLQuery;

                //Connect to correct database
                using (SqlConnection mConnection = new SqlConnection(Connection[queueData.map.connection_id]))
                {
                    mConnection.Open();
                    //Get a list of all ther table names in the Database
                    using (SqlCommand command = new SqlCommand(cmd, mConnection))
                    {
                        command.ExecuteNonQuery();
                    }
                    mConnection.Dispose();
                    // mConnection.Dispose();
                }

                pr.Successful  = true;
                pr.Information = "Success";

                return(pr);
            }


            catch (Exception ex)
            {
                // Console.WriteLine(ex.Message);


                pr.Successful  = false;
                pr.Information = String.Format("Exception Message: {0} ||" +
                                               " Exception Stack Trace: {1} ||" +
                                               " Exception Inner Ex: {2} ", ex.Message, ex.StackTrace, ex.InnerException);


                return(pr);
            }
        }