text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Persistence.Repositories;
using Umbraco.Cms.Core.Scoping;
using Umbraco.Cms.Core.Sync;
using Umbraco.Extensions;

namespace Umbraco.Cms.Core.Services.Implement
{
    /// <summary>
    /// Implements <see cref="ICacheInstructionService"/> providing a service for retrieving and saving cache instructions.
    /// </summary>
    public class CacheInstructionService : RepositoryService, ICacheInstructionService
    {
        private readonly ICacheInstructionRepository _cacheInstructionRepository;
        private readonly IProfilingLogger _profilingLogger;
        private readonly ILogger<CacheInstructionService> _logger;
        private readonly GlobalSettings _globalSettings;

        /// <summary>
        /// Initializes a new instance of the <see cref="CacheInstructionService"/> class.
        /// </summary>
        public CacheInstructionService(
            IScopeProvider provider,
            ILoggerFactory loggerFactory,
            IEventMessagesFactory eventMessagesFactory,
            ICacheInstructionRepository cacheInstructionRepository,
            IProfilingLogger profilingLogger,
            ILogger<CacheInstructionService> logger,
            IOptions<GlobalSettings> globalSettings)
            : base(provider, loggerFactory, eventMessagesFactory)
        {
            _cacheInstructionRepository = cacheInstructionRepository;
            _profilingLogger = profilingLogger;
            _logger = logger;
            _globalSettings = globalSettings.Value;
        }

        /// <inheritdoc/>
        public bool IsColdBootRequired(int lastId)
        {
            using (IScope scope = ScopeProvider.CreateScope(autoComplete: true))
            {
                if (lastId <= 0)
                {
                    var count = _cacheInstructionRepository.CountAll();

                    // If there are instructions but we haven't synced, then a cold boot is necessary.
                    if (count > 0)
                    {
                        return true;
                    }
                }
                else
                {
                    // If the last synced instruction is not found in the db, then a cold boot is necessary.
                    if (!_cacheInstructionRepository.Exists(lastId))
                    {
                        return true;
                    }
                }

                return false;
            }
        }
        /// <inheritdoc/>
        public bool IsInstructionCountOverLimit(int lastId, int limit, out int count)
        {
            using (IScope scope = ScopeProvider.CreateScope(autoComplete: true))
            {
                // Check for how many instructions there are to process, each row contains a count of the number of instructions contained in each
                // row so we will sum these numbers to get the actual count.
                count = _cacheInstructionRepository.CountPendingInstructions(lastId);
                return count > limit;
            }
        }

        /// <inheritdoc/>
        public int GetMaxInstructionId()
        {
            using (IScope scope = ScopeProvider.CreateScope(autoComplete: true))
            {
                return _cacheInstructionRepository.GetMaxId();
            }
        }

        /// <inheritdoc/>
        public void DeliverInstructions(IEnumerable<RefreshInstruction> instructions, string localIdentity)
        {
            CacheInstruction entity = CreateCacheInstruction(instructions, localIdentity);

            using (IScope scope = ScopeProvider.CreateScope())
            {
                _cacheInstructionRepository.Add(entity);
                scope.Complete();
            }
        }

        /// <inheritdoc/>
        public void DeliverInstructionsInBatches(IEnumerable<RefreshInstruction> instructions, string localIdentity)
        {
            // Write the instructions but only create JSON blobs with a max instruction count equal to MaxProcessingInstructionCount.
            using (IScope scope = ScopeProvider.CreateScope())
            {
                foreach (IEnumerable<RefreshInstruction> instructionsBatch in instructions.InGroupsOf(_globalSettings.DatabaseServerMessenger.MaxProcessingInstructionCount))
                {
                    CacheInstruction entity = CreateCacheInstruction(instructionsBatch, localIdentity);
                    _cacheInstructionRepository.Add(entity);
                }

                scope.Complete();
            }
        }

        private CacheInstruction CreateCacheInstruction(IEnumerable<RefreshInstruction> instructions, string localIdentity) =>
            new CacheInstruction(0, DateTime.UtcNow, JsonConvert.SerializeObject(instructions, Formatting.None), localIdentity, instructions.Sum(x => x.JsonIdCount));

        /// <inheritdoc/>
        public ProcessInstructionsResult ProcessInstructions(
            CacheRefresherCollection cacheRefreshers,
            ServerRole serverRole,
            CancellationToken cancellationToken,
            string localIdentity,
            DateTime lastPruned,
            int lastId)
        {
            using (_profilingLogger.DebugDuration<CacheInstructionService>("Syncing from database..."))
            using (IScope scope = ScopeProvider.CreateScope())
            {
                var numberOfInstructionsProcessed = ProcessDatabaseInstructions(cacheRefreshers, cancellationToken, localIdentity, ref lastId);

                // Check for pruning throttling.
                if (cancellationToken.IsCancellationRequested || (DateTime.UtcNow - lastPruned) <= _globalSettings.DatabaseServerMessenger.TimeBetweenPruneOperations)
                {
                    scope.Complete();
                    return ProcessInstructionsResult.AsCompleted(numberOfInstructionsProcessed, lastId);
                }

                var instructionsWerePruned = false;
                switch (serverRole)
                {
                    case ServerRole.Single:
                    case ServerRole.SchedulingPublisher:
                        PruneOldInstructions();
                        instructionsWerePruned = true;
                        break;
                }

                scope.Complete();

                return instructionsWerePruned
                    ? ProcessInstructionsResult.AsCompletedAndPruned(numberOfInstructionsProcessed, lastId)
                    : ProcessInstructionsResult.AsCompleted(numberOfInstructionsProcessed, lastId);
            }
        }

        /// <summary>
        /// Process instructions from the database.
        /// </summary>
        /// <remarks>
        /// Thread safety: this is NOT thread safe. Because it is NOT meant to run multi-threaded.
        /// </remarks>
        /// <returns>Number of instructions processed.</returns>
        private int ProcessDatabaseInstructions(CacheRefresherCollection cacheRefreshers, CancellationToken cancellationToken, string localIdentity, ref int lastId)
        {
            // NOTE:
            // We 'could' recurse to ensure that no remaining instructions are pending in the table before proceeding but I don't think that
            // would be a good idea since instructions could keep getting added and then all other threads will probably get stuck from serving requests
            // (depending on what the cache refreshers are doing). I think it's best we do the one time check, process them and continue, if there are
            // pending requests after being processed, they'll just be processed on the next poll.
            //
            // TODO: not true if we're running on a background thread, assuming we can?

            // Only retrieve the top 100 (just in case there are tons).
            // Even though MaxProcessingInstructionCount is by default 1000 we still don't want to process that many
            // rows in one request thread since each row can contain a ton of instructions (until 7.5.5 in which case
            // a row can only contain MaxProcessingInstructionCount).
            const int MaxInstructionsToRetrieve = 100;

            // Only process instructions coming from a remote server, and ignore instructions coming from
            // the local server as they've already been processed. We should NOT assume that the sequence of
            // instructions in the database makes any sense whatsoever, because it's all async.

            // Tracks which ones have already been processed to avoid duplicates
            var processed = new HashSet<RefreshInstruction>();
            var numberOfInstructionsProcessed = 0;

            // It would have been nice to do this in a Query instead of Fetch using a data reader to save
            // some memory however we cannot do that because inside of this loop the cache refreshers are also
            // performing some lookups which cannot be done with an active reader open.
            IEnumerable<CacheInstruction> pendingInstructions = _cacheInstructionRepository.GetPendingInstructions(lastId, MaxInstructionsToRetrieve);
            lastId = 0;
            foreach (CacheInstruction instruction in pendingInstructions)
            {
                // If this flag gets set it means we're shutting down! In this case, we need to exit asap and cannot
                // continue processing anything otherwise we'll hold up the app domain shutdown.
                if (cancellationToken.IsCancellationRequested)
                {
                    break;
                }

                if (instruction.OriginIdentity == localIdentity)
                {
                    // Just skip that local one but update lastId nevertheless.
                    lastId = instruction.Id;
                    continue;
                }

                // Deserialize remote instructions & skip if it fails.
                if (!TryDeserializeInstructions(instruction, out JArray jsonInstructions))
                {
                    lastId = instruction.Id; // skip
                    continue;
                }

                List<RefreshInstruction> instructionBatch = GetAllInstructions(jsonInstructions);

                // Process as per-normal.
                var success = ProcessDatabaseInstructions(cacheRefreshers, instructionBatch, instruction, processed, cancellationToken, ref lastId);

                // If they couldn't be all processed (i.e. we're shutting down) then exit.
                if (success == false)
                {
                    _logger.LogInformation("The current batch of instructions was not processed, app is shutting down");
                    break;
                }

                numberOfInstructionsProcessed++;
            }

            return numberOfInstructionsProcessed;
        }

        /// <summary>
        /// Attempts to deserialize the instructions to a JArray.
        /// </summary>
        private bool TryDeserializeInstructions(CacheInstruction instruction, out JArray jsonInstructions)
        {
            if (instruction.Instructions is null)
            {
                _logger.LogError("Failed to deserialize instructions ({DtoId}: 'null').", instruction.Id);
                jsonInstructions = null;
                return false;
            }

            try
            {
                jsonInstructions = JsonConvert.DeserializeObject<JArray>(instruction.Instructions);
                return true;
            }
            catch (JsonException ex)
            {
                _logger.LogError(ex, "Failed to deserialize instructions ({DtoId}: '{DtoInstructions}').",
                    instruction.Id,
                    instruction.Instructions);
                jsonInstructions = null;
                return false;
            }
        }

        /// <summary>
        /// Parses out the individual instructions to be processed.
        /// </summary>
        private static List<RefreshInstruction> GetAllInstructions(IEnumerable<JToken> jsonInstructions)
        {
            var result = new List<RefreshInstruction>();
            foreach (JToken jsonItem in jsonInstructions)
            {
                // Could be a JObject in which case we can convert to a RefreshInstruction.
                // Otherwise it could be another JArray - in which case we'll iterate that.
                if (jsonItem is JObject jsonObj)
                {
                    RefreshInstruction instruction = jsonObj.ToObject<RefreshInstruction>();
                    result.Add(instruction);
                }
                else
                {
                    var jsonInnerArray = (JArray)jsonItem;
                    result.AddRange(GetAllInstructions(jsonInnerArray)); // recurse
                }
            }

            return result;
        }

        /// <summary>
        /// Processes the instruction batch and checks for errors.
        /// </summary>
        /// <param name="processed">
        /// Tracks which instructions have already been processed to avoid duplicates
        /// </param>
        /// Returns true if all instructions in the batch were processed, otherwise false if they could not be due to the app being shut down
        /// </returns>
        private bool ProcessDatabaseInstructions(
            CacheRefresherCollection cacheRefreshers,
            IReadOnlyCollection<RefreshInstruction> instructionBatch,
            CacheInstruction instruction,
            HashSet<RefreshInstruction> processed,
            CancellationToken cancellationToken,
            ref int lastId)
        {
            // Execute remote instructions & update lastId.
            try
            {
                var result = NotifyRefreshers(cacheRefreshers, instructionBatch, processed, cancellationToken);
                if (result)
                {
                    // If all instructions were processed, set the last id.
                    lastId = instruction.Id;
                }

                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(
                    ex,
                    "DISTRIBUTED CACHE IS NOT UPDATED. Failed to execute instructions ({DtoId}: '{DtoInstructions}'). Instruction is being skipped/ignored",
                    instruction.Id,
                    instruction.Instructions);

                // We cannot throw here because this invalid instruction will just keep getting processed over and over and errors
                // will be thrown over and over. The only thing we can do is ignore and move on.
                lastId = instruction.Id;
                return false;
            }
        }

        /// <summary>
        /// Executes the instructions against the cache refresher instances.
        /// </summary>
        /// <returns>
        /// Returns true if all instructions were processed, otherwise false if the processing was interrupted (i.e. by app shutdown).
        /// </returns>
        private bool NotifyRefreshers(
            CacheRefresherCollection cacheRefreshers,
            IEnumerable<RefreshInstruction> instructions,
            HashSet<RefreshInstruction> processed,
            CancellationToken cancellationToken)
        {
            foreach (RefreshInstruction instruction in instructions)
            {
                // Check if the app is shutting down, we need to exit if this happens.
                if (cancellationToken.IsCancellationRequested)
                {
                    return false;
                }

                // This has already been processed.
                if (processed.Contains(instruction))
                {
                    continue;
                }

                switch (instruction.RefreshType)
                {
                    case RefreshMethodType.RefreshAll:
                        RefreshAll(cacheRefreshers, instruction.RefresherId);
                        break;
                    case RefreshMethodType.RefreshByGuid:
                        RefreshByGuid(cacheRefreshers, instruction.RefresherId, instruction.GuidId);
                        break;
                    case RefreshMethodType.RefreshById:
                        RefreshById(cacheRefreshers, instruction.RefresherId, instruction.IntId);
                        break;
                    case RefreshMethodType.RefreshByIds:
                        RefreshByIds(cacheRefreshers, instruction.RefresherId, instruction.JsonIds);
                        break;
                    case RefreshMethodType.RefreshByJson:
                        RefreshByJson(cacheRefreshers, instruction.RefresherId, instruction.JsonPayload);
                        break;
                    case RefreshMethodType.RemoveById:
                        RemoveById(cacheRefreshers, instruction.RefresherId, instruction.IntId);
                        break;
                }

                processed.Add(instruction);
            }

            return true;
        }

        private void RefreshAll(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier)
        {
            ICacheRefresher refresher = GetRefresher(cacheRefreshers, uniqueIdentifier);
            refresher.RefreshAll();
        }

        private void RefreshByGuid(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier, Guid id)
        {
            ICacheRefresher refresher = GetRefresher(cacheRefreshers, uniqueIdentifier);
            refresher.Refresh(id);
        }

        private void RefreshById(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier, int id)
        {
            ICacheRefresher refresher = GetRefresher(cacheRefreshers, uniqueIdentifier);
            refresher.Refresh(id);
        }

        private void RefreshByIds(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier, string jsonIds)
        {
            ICacheRefresher refresher = GetRefresher(cacheRefreshers, uniqueIdentifier);
            foreach (var id in JsonConvert.DeserializeObject<int[]>(jsonIds))
            {
                refresher.Refresh(id);
            }
        }

        private void RefreshByJson(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier, string jsonPayload)
        {
            IJsonCacheRefresher refresher = GetJsonRefresher(cacheRefreshers, uniqueIdentifier);
            refresher.Refresh(jsonPayload);
        }

        private void RemoveById(CacheRefresherCollection cacheRefreshers, Guid uniqueIdentifier, int id)
        {
            ICacheRefresher refresher = GetRefresher(cacheRefreshers, uniqueIdentifier);
            refresher.Remove(id);
        }

        private ICacheRefresher GetRefresher(CacheRefresherCollection cacheRefreshers, Guid id)
        {
            ICacheRefresher refresher = cacheRefreshers[id];
            if (refresher == null)
            {
                throw new InvalidOperationException("Cache refresher with ID \"" + id + "\" does not exist.");
            }

            return refresher;
        }

        private IJsonCacheRefresher GetJsonRefresher(CacheRefresherCollection cacheRefreshers, Guid id) => GetJsonRefresher(GetRefresher(cacheRefreshers, id));

        private static IJsonCacheRefresher GetJsonRefresher(ICacheRefresher refresher)
        {
            if (refresher is not IJsonCacheRefresher jsonRefresher)
            {
                throw new InvalidOperationException("Cache refresher with ID \"" + refresher.RefresherUniqueId + "\" does not implement " + typeof(IJsonCacheRefresher) + ".");
            }

            return jsonRefresher;
        }

        /// <summary>
        /// Remove old instructions from the database
        /// </summary>
        /// <remarks>
        /// Always leave the last (most recent) record in the db table, this is so that not all instructions are removed which would cause
        /// the site to cold boot if there's been no instruction activity for more than TimeToRetainInstructions.
        /// See: http://issues.umbraco.org/issue/U4-7643#comment=67-25085
        /// </remarks>
        private void PruneOldInstructions()
        {
            DateTime pruneDate = DateTime.UtcNow - _globalSettings.DatabaseServerMessenger.TimeToRetainInstructions;
            _cacheInstructionRepository.DeleteInstructionsOlderThan(pruneDate);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
Waste sites reopen in London and Surrey with help from 'CSAS staff'
A traffic management, stewarding and security company put together detailed plans at very short notice for the reopening of six waste and recycling centres in North London following the Government's easing of coronavirus lockdown restrictions – before deploying its own staff with specialist police powers to manage the queues and ensure the flow of through-traffic.
Commissioned by the North London Waste Authority (NLWA), The Combined Services Provider Limited (CSP), a Watford-based company, had just one week from initial enquiry to live operations to design and implement a detailed plan for the reopening of sites in Barnet, Chingford, Haringey, Islington, Leyton and Walthamstow.
The plans had to be approved by each of the respective local authorities and the Metropolitan Police, along with arranging traffic management signage and manufacture of 20 Covid-19 signs.
At the same time, CSP were also approached by Surrey Police – also with about a week's notice – to assist with the reopening of eight waste sites, with four of them at Earlswood, Guildford, Leatherhead and Woking requiring staff with police powers (see the next three photos below).
Their staff were accredited with certain police powers in London by the Metropolitan Police Commissioner and in Surrey by the Chief Constable under the Community Safety Accreditation Scheme (CSAS), a voluntary scheme, contained in Section 40 of the Police Reform Act 2002.
CSP's CSAS responsibilities include managing safe vehicle movements in the queues to the sites and at key junctions and roundabouts near the sites whilst minimising impact on local residents and through traffic.
At the NLWA centres, which are allowing residents to pre-book online to dispose of any household or garden waste that would put them at risk of harm in their home, CSP carried out a total of 80 CSAS shifts at the six sites between 13-19 May.
At the Surrey centres, which originated from a request by the Surrey Police CSAS Liaison Officer, CSP's focus was on providing CSAS staff to assist as Surrey County Council had designed traffic plans, signage and equipment. From 11 May, CSP was initially contracted for 167 CSAS shifts at the four sites, which are allowing cars only and only one black bag of waste and garden waste.
However, due to the success of their operations in Surrey, CSP's role at Guildford was extended from 15 May to the end of May.
CSP also received a referral to assist with the Recycling Centre in the London Borough of Richmond where CSAS shifts began on 18 May and will run until the end of June.
Tony Nikolic, Managing Director, CSP, said the NLWA had been passing on CSP's details to other local authorities encountering traffic problems at their recycling centres. Feedback in Surrey had been positive too, he said. "We have several sites looking to extend our presence onsite and rebook our services in the future when the sites are allowed to ease their restrictions further."
Since 12 May, CSP has also provided CSAS staff to assist with the launch of the drive-through NHS Coronavirus Test Centre at North Greenwich (see photo immediately below).
Tony added: "We have found our police contacts in the Metropolitan Police and Surrey Police to be extremely helpful and supportive and we like to feel that after ten years of working with the police we are very much trusted to deploy CSAS accredited staff.
"Given the pressures that the police and local authorities are under currently, we believe that our work at the recycling centres has been vital in allowing these critical services to be reopened and well managed."
Guy Ferguson, Chief Executive Officer, PCPI, said: "This is an excellent example of where properly trained and accredited staff can help their communities, especially in these challenging times. The CSAS initiative is an excellent route to swiftly provide staff to assist in policing duties, which enables warranted police officers to be utilised elsewhere."
Surrey Chief Constable, Gavin Stephens, said: "This scheme has provided extra support to our waste recycling centres and lessened any impact on nearby communities without using up the valuable time of our local officers who are working hard to keep everyone safe."
Superintendent Elisabeth Chapple, Professionalism Headquarters, Metropolitan Police, said: "CSAS Accredited Persons, whether they are members of private companies or public organisations, play a growing role of importance and benefit to the community. This example shows the flexibility of the scheme in challenging times."
Andrew O'Connor, Head of Strategy and Services for NLWA, said: "CSP provided a great service by assisting in the re-opening of six of our seven recycling centres in North London. With the help of their CSAS operatives we were able to implement robust plans on the approaches to the sites which prevented excessive queuing and minimised any impact on the road network. We were very grateful for the support CSP Head of Operations gave us in holding our hands through something very new to the Authority."
About The Combined Services Provider Limited (CSP)
Since CSP's first event contract in 1994, the company has grown its range of services to specialise in providing traffic management and car parking, security and stewarding, and hostile vehicle mitigation solutions, as well as other services which include cash and audit and consultancy. Well-versed in managing the complexities of major events, CSP now provides a range of services to some of the UK's most memorable sporting and entertainment events. These have included UEFA Champions League Finals, Ryder Cup golf tournaments between European and USA, the three-day Road Cycle Race for the London 2012 Olympic Games, Twickenham Rugby Stadium match days, and the three Jockey Club Racecourses in London – Epsom Downs, Kempton Park and Sandown Park.
Web: https://www.gotocsp.com

redpajama_set_name: RedPajamaCommonCrawl


text:
On Tuesday, the Carnival Cruise Line was denied a request to dock in Bonaire, which is part of the Kingdom of the Netherlands. The Dutch government stated that they were…
The Norwegian Cruise Line announced their most popular itinerary is a 9-day cruise to Norway. The trip features everything from fjords, hot springs and ice caves! "Norwegian Encores Cruise COVID"…
Following the reopening of its main airport in Nassau, The Bahamas lowered travel advisories from the US State Department and Centers for Disease Control. The "bahamas covid travel requirements" is…
Carnival Cruise Line has released an update on the status of seven cruise directors that were suspended during three separate incidents. The company is giving updates based on what it…
When it comes to travel, we're constantly faced with new options. From booking flights and hotels online to staying at a friend's pad abroad, there are endless ways for travelers…
The ship, which will be Royal Caribbean's second-largest ever after the Oasis of the Seas, is scheduled to set sail from Port Canaveral in 2022. It will feature a rock…
Royal Caribbean Update on Re-Entry Testing, Casino Smoking, and Final Payment
Royal Caribbean has reported a re-entry test for their cruise ships after two incidents involving casino smokers. Testing will take place in the late fall, but there is no word…
Travel Advisors Report Strong Winter Bookings
U.S hotel industry reports strong winter bookings, despite a late-start to the travel season and increased tariffs on certain imports from China. The "travel insights 2021" is a report that…
9 Things That Will Keep You From Getting Stranded In The Airport
The airport is a series of confusing and frustrating experiences. There are so many people, flights to catch, luggage struggles- it can be overwhelming! This article will offer some helpful…
Greece To Require Pre-Travel PCR Test Taken Within 48 Hours
Greek authorities have released new recommendations for travelers, including a recommendation that they should take their own DNA samples before traveling. The regulations are in response to the country's ongoing…
Bahamas' Arrivals Will Recover This Winter Says Resort Chief
What To See and Do in St. Augustine, Florida This Fall
Road Trip From Seattle To Vancouver


Cute Hairstyles for Long Black Hair Easy Hairstyles for Black Hair Easy Hairstyles for Long Mоѕt wоmеn enjoy having long hair bесаuѕе they саn do virtually any hаіrѕtуlе thаt іѕ knоwn to man. From ѕіmрlе waves tо complicated bunѕ, Cute Hairstyles for Long Black Hair Easy Hairstyles for Black Hair Easy Hairstyles for Long having long hair саn do just that. However, іf you аrе gеttіng tіrеd оf having thе ѕаmе boring hаіrѕtуlе, here аrе some іntеrеѕtіng hаіrѕtуlеѕ thаt уоu can trу out Cute Hairstyles for Long Black Hair Easy Hairstyles for Black Hair Easy Hairstyles for Long .
11 photos of the "Unique Cute Hairstyles for Long Black Hair"
Related Posts of "Cute Hairstyles for Long Black Hair Easy Hairstyles for Black Hair Easy Hairstyles for Long"


The Chicago Blackhawks compete in the Central Division of the National Hockey League. The team was founded in 1926, making it one of the oldest in the entire league. With that being said, it is safe to say that the Blackhawks have earned quite a reputation over that time. And the good thing for Blackhawks fans is that this is not going to slow down anytime in the near future.
The Blackhawks play their home games at the United Center. This venue is one of the nicest in the league, and this shows through by the number of fans who support the team at each home game. Seeing a Blackhawks game at the United Center is an experience that you will not soon forget.
Many great players have competed for the Blackhawks over the years. Some of the best include Glenn Hall, Bobby Hull, Stan Mikita, Tony Esposito, and many more.
Overall, the Chicago Blackhawks are one of the oldest franchises in the National Hockey League. Since beginning play in 1926, they have won thousands of games and are on their way to many more in the future.
We have a huge selection of Chicago Blackhawks Tickets to choose from, including Chicago Blackhawks games at United Center and away. Find all Chicago Blackhawks tickets and view the Chicago Blackhawks schedule here. Choose a date and start planning your evening with the Chicago Blackhawks today!


text:
Podcasts presented by Matt Dickson
Policy Matters (8)
Presenter: Matt Dickson
Policy Matters: The future of social mobility
Policy Matters
In this episode of Policy Matters, hosts Franz Buscha and Matt Dickson discuss the recently published 'Augar Review' of Post-18 education and funding; explaining what it is, how it came about, and what the main recommendations are. Franz and Matt consider the impact changes the HE funding system might have on students, in particular whether this would be a good or bad thing for social mobility, and whether or not politics may intervene to prevent these recommendations being implemented in any case. In light of recent public debate around whether social mobility should even be a policy objective, the discussion moves on to considering what social mobility entails and how it relates to the broader concept of social justice.
Franz Buscha
Published: Fri 12 Jul 2019
Policy Matters: 20 years of the national minimum wage and how economists help shape pay policy
In this episode of Policy Matters, hosts Franz Buscha and Matt Dickson talk to Sarah Brown, Professor of Economics at the University of Sheffield and an independent commissioner for the Low Pay Commission. Franz and Matt highlight the 20th anniversary of the introduction of the national minimum wage and discuss with Sarah how the policy has worked out for the UK. The role and importance of the Low Pay Commission in informing minimum wage policy is explored and questions are asked as to what the future may hold for the minimum wage. The discussion then moves to the topic of household finances and how people with different personality traits make financial decisions and the implications this may have for policy.
Franz Buscha, Sarah Brown
Policy Matters: How can economists help the Dept. of Health and Social Care?
In this episode of Policy Matters, hosts Matt Dickson and Franz Buscha talk to Carol Propper, Professor of Economics at Imperial College London and a former Senior Economic Advisor to the NHS Executive on Regulation of the NHS Internal Market. We might not immediately think of economists when we think about healthcare, but Carol explains how economists can help with the design of a healthcare system that will produce the health outcomes that we would all want, taking into account the incentives faced by the various people and institutions involved. Matt, Franz and Carol discuss socio-economic inequalities in health and their relationship with healthcare before Carol gives us her prescription for the NHS and looks ahead to how future research might help improve healthcare in this country.
Carol Propper
Published: Thu 04 Apr 2019
Policy Matters: Why are there so few women in economics and what can be done about it?
Historically, economics as a discipline has been dominated by men – and despite increases in the proportion of female lecturers and professors in recent years, women remain under-represented. In this episode of Policy Matters, hosts Matt Dickson and Franz Buscha talk to Sarah Smith, Professor of Economics at the University of Bristol and head of the Royal Economics Society's Women's Committee. They discuss the need to change girls' perceptions of what economists actually do, and to encourage more young women to take economics at A-level and at University. Sarah explains how within academia there remain barriers to career progression for women and that raising awareness of this amongst the male-dominated hierarchies is an important step in helping to level the playing field. The discussion closes thinking about what economics can learn from other disciplines that have made greater strides towards gender equality.
Franz Buscha, Sarah Smith
Published: Fri 01 Mar 2019
Policy Matters meets Economist Questions
This episode of Policy Matters is a cross-over show in which hosts Franz Buscha and Matt Dickson are joined by the host of Economist Questions, Peter Urwin. As Peter is currently leading a large research project looking at young people's pathways through education, Franz and Matt ask him about his own journey and how that affected his social mobility. They go on to discuss the problems that the Further Education system faces in providing both second chances for those who don't achieve well at age 16 as well as higher-level training for those more suited to the vocational route. All this in the context of dwindling education budgets in general, and a lack of policy focus on the Further Education system.
Franz Buscha, Peter Urwin
Published: Fri 04 Jan 2019
Policy Matters: What did we learn about social mobility?
In this first episode of the new series of Policy Matters, hosts Franz Buscha and Matt Dickson spent some time reflecting back on their previous guests and discuss some of the key messages that each episode brought up. Why is social mobility important? Are grammar schools good for social mobility? Are there upsides to vocational education and why should HE students take care when selecting degrees? Both Matt and Franz highlight particular lessons learned and how they relate to current policy. Franz and Matt then look forward to this new season of Policy Matters and discuss topics such as health, crime, gender and happiness that will be explored in more detail in future episodes.
Policy Matters: The role of vocational education in modern Britain
In the final episode of the current series of Policy Matters, hosts Franz Buscha and Matt Dickson talk to Sandra McNally, Professor of Economics at the University of Surrey and Director of the Centre for Vocational Education Research. When it comes to education, much of the public debate and media attention focuses on the traditional academic route of A-levels and University. But what about the 50% of young people who don't ever go to University – what are the options for them and are they as consistently neglected by policymakers as they are by the media and wider public? Sandra explains the vocational route compared to the academic pathway and discusses the merits of vocational qualifications, highlighting recent evidence on their labour market returns. Franz, Matt and Sandra go on to discuss how the structure of the UK economy, the incentives for training and the priorities of young people and employers interact within the vocational system, asking what could be done to improve this education route for young people and older workers who wish to continue learning.
Franz Buscha, Sandra McNally
Policy Matters: The Economics of Higher Education
In this episode of Policy Matters, host Matt Dickson talks to Laura van der Erve from the Institute for Fiscal Studies about the merits of doing a university degree, and what recent evidence suggests are the relative labour market returns to degrees in different subjects at different institutions. With almost 50% of young people in England going on to Higher Education, and with tuition fees of £9,250 for most courses, it has never been more important to understand the impact on earnings of studying different subjects and at different HE institutions. Laura describes recent research from the IFS looking at graduate outcomes and explains some of the difficulties in pinning down the impact of a particular course on later earnings and employment. They then discuss social gradients in attending university and the extent to which inequalities have been impacted by changes in tuition fees. Finally, talk turns to thinking about the sorts of things students need to know in advance in order to make an informed decision about where to apply and what to study, how the government can help with this, and the limits of information provision as a policy.
Laura van der Erve


Utah Gun Laws: Can Towns and Cities Make Local Rules?
Utah gun laws are considered some of the more permissive in the country. The state's dearth of legislation on firearm regulations is intended to protect citizen's Second Amendment rights. Utah's towns and cities are strictly bound to be uniform with state legislation, which ranked Utah as the lowest among all 50 states in the category of gun control legislation, according to a 2013 study by Journal of American Medical Association Internal Medicine.
"All authority to regulate firearms is reserved to the state except where the Legislature specifically delegates responsibility to local authorities or state entities."
When Park City enacted its own regulations that exceeded the reach of state laws, a Second Amendment advocacy group was quick to call them on it. Eventually, city officials voted to repeal the measures.
The Second Amendment Foundation, an organization "dedicated to promoting a better understanding about our constitutional heritage to privately own and possess firearms," compelled Park City, Utah, to roll back firearms regulations that run afoul of state law and the Constitution.
The release cited four City Hall regulations that did not follow the state laws: a prohibition on the use and possession of firearms, the carrying of concealed weapons, carrying a loaded gun inside a vehicle or in a street or in a posted area where guns are prohibited, and a prohibition on someone drawing or showing a gun in "an angry or threatening manner," which prevented displaying a firearm in self-defense without actually firing the gun.
The SAF had cautioned the city that failure to bring the code into compliance with state law puts Park City at risk for a lawsuit.
However, in 2013, Spring City, a rural town in central Utah, passed an ordinance without much opposition that "encourages" all its residents to own a firearm, according to the Los Angeles Times.
Utah towns and cities are strictly bound to be uniform with state gun laws, which ranked Utah lowest among all 50 states in the category of gun control legislation, according to a 2013 study by the Journal of American Medical Association Internal Medicine.


text:
{% load staticfiles %}
{% load bootstrap_tags %}
<!DOCTYPE html>

  <meta charset="utf-8">

  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">

  <link href="{% static "css/bootstrap/bootstrap.min.css" %}" rel="stylesheet">

  <link href="{% static "css/style.css" %}" rel="stylesheet">

  <link rel="icon" href="{% static "favicon.ico" %}">

  <title>Jay - {% block page_title %}Base{% endblock %}</title>
{% block head %}{% endblock %}

              Jay

            {% block nav-header %}
            {% endblock %}

                {%if user.is_authenticated %}

                    {{ user.username }}

                    {% if user.profile.isSuperAdmin %}

Management

Voting Systems

Super Admins

                    {% endif %}

                    {% with admin_for=user.profile.getAdministratedSystems %}

                      {% if admin_for|length > 0 %}

Voting Systems

                        {% for vs in admin_for %}
                          {% url 'votes:system' system_name=vs.machine_name as vs_url %}

{{ vs.simple_name }}

                        {% endfor %}

Filters

The Forest

                      {% endif %}

                    {% endwith %}

Logout

                {% else %}
                  Login
                {% endif %}

    {% block content %}

This is Jay, your friendly voting system.

    {% endblock %}

            © 2015-17 Leonhard Kuboschek, Tom Wiesing & Contributors

            Imprint
            Privacy Policy
            Source Code

{% block scripts %}

{% endblock %}


Before we get to a discussion on the present and future of eCommerce of India, we should look at the reasons as to why it is a sector that has the potential to be big in India.
First, the sector has grown because of the growth of the Internet in India. A decade ago, the user base was very thin. Now, with 100 million users on the Internet, there is critical mass. Also, in the interim, ticketing emerged as a big thing. Booking train tickets for many and flight tickets for some became their first introduction to the world of eCommerce. That is now extending to other sectors.
Second, in metros, there is the convenience. For many who are pressed for time, a few clicks is all it takes to order and have it delivered him. It saves a trip to the nearby mall where parking can be a challenge.
Third, in the smaller towns, there is the sheer variety available. Given the costs of retail stores and their limited expansion in India, the Internet stores are bridging the gap by making everything available to everyone across India. It is no surprise then that the majority of orders on eCommerce sites are now coming from non-metro locations.


I have had the Pleasure of Photographing Gary & Kristina's Family for Several Years Now. They are Excellent People and A LOT of Fun to Work with. Fall Colors are Great for Pictures but I have yet to find an UGLY place on our Mountain in any Time of Year.


text:
Photo: Doug Lange
Say goodbye to the old scoreboard at Joe Martin Field. The Bellingham Bells announced Monday the ballpark will get a new scoreboard for the 2018 season. According to a press release from the Bells, the scoreboard will completely replace the current existing structure and feature a new design with full video display capabilities.
The new scoreboard has been made possible by financial support from the International Brotherhood of Electrical Workers - Local 191 & National Electrical Contractors Association - Cascade Chapter. The City of Bellingham and VECA Electric have also offered support and assistance on the project.
"We are extremely excited for the facility to receive this major upgrade," Bells' general manager Stephanie Morrell said. "IBEW 191 & NECA - Cascade are wonderfully supportive of our team and community and we are so thankful for their partnership on this project. Without their support, this project simply would not have been possible. Additionally, we are grateful to the City of Bellingham and VECA Electric for their support, coordination and assistance in making this new scoreboard a reality. This is a very exciting addition to an already incredible City of Bellingham facility."
"The City of Bellingham and our community have enjoyed a great working relationship with the Bellingham Bells," City of Bellingham Mayor Kelli Linville said. "We are grateful for this donation and know it will serve Joe Martin Stadium and the community for years to come."
The scoreboard is a gift to the City of Bellingham and will be enjoyed by the hundreds of community user groups who utilize the facility annually, including high school and community athletic groups.
"When we approached IBEW 191 & NECA - Cascade about partnering on this project, one of the things we were all equally excited about was the ability not only to have a state-of-the-art scoreboard for the Bells' season, but also to be able to share this new amazing resource with the entire community and all of the groups that use this facility," Morrell said. "This will be an amazing community asset and addition to the facility. We are very grateful to everyone who has helped make this a reality."
bellinghambells.com.
Bellingham Bells press release edited by The Doug Lange Network.


This is Mark Zuckerberg, the creator of Facebook.
"At Facebook I spend a lot of time working with engineers to build new things. Some of the most rewarding work involves getting deep into the details of technical projects... But it's a different kind of rewarding to build things yourself, so this year my personal challenge is to do that," Zuckerberg wrote.
The comment reads: "I keep telling my granddaughters to date the nerd in school, he may turn out to be a Mark Zuckerberg! Thanks for FB, I've reconnected with family and old friend and classmates."
"Even better would be to encourage them to *be* the nerd in their school so they can be the next successful inventor!"
Solid advice for young women, Zuckerberg.