protected void Application_Start()
        {
            // create empty config database if it not exists
            Database.SetInitializer(new ConfigurationDatabaseInitializer());
            ModelMetadataProviders.Current = new MetadataProvider();
            // set the anti CSRF for name (that's a unqiue claim in our system)
            AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.Name;

            // setup MEF
            SetupCompositionContainer();
            Container.Current.SatisfyImportsOnce(this);

            AreaRegistration.RegisterAllAreas();

            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters, ConfigurationRepository);
            RouteConfig.RegisterRoutes(RouteTable.Routes, ConfigurationRepository, UserRepository);
            ProtocolConfig.RegisterProtocols(GlobalConfiguration.Configuration, RouteTable.Routes, ConfigurationRepository, UserRepository, RelyingPartyRepository);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
            var authConfig = new AuthConfig();
            authConfig.RegisterAllIdentityProviders();
            //Communicator = Communicator<DynamicsSendJob, DynamicsReceiveJob>.InitializeAndStart();
        }
        public ActionResult Update(IdentityProvider model, IPCertInputModel cert, string action)
        {
            if (action == "delete")
            {
                this.identityProviderRepository.Delete(model.ID);
                TempData["Message"] = Resources.IPController.IdentityProvidersDeleted;
                return RedirectToAction("Index");
            }

            if (cert != null && cert.Cert != null)
            {
                model.IssuerThumbprint = cert.Cert.Thumbprint;
                ModelState["IssuerThumbprint"].Errors.Clear();
            }

            if (ModelState.IsValid)
            {
                try
                {
                    this.identityProviderRepository.Update(model);
                    TempData["Message"] = Resources.IPController.IdentityProviderUpdated; ;
                    var config = new AuthConfig();
                    if (model.Type == IdentityProviderTypes.OAuth2)
                    {
                        config.RegisterOauth2IdentityProvider(model);
                    }
                    else if (model.Type == IdentityProviderTypes.OpenId)
                    {
                        config.RegisterOauth2IdentityProvider(model);
                    }
                    return RedirectToAction("IP", new { id = model.ID });
                }
                catch (ValidationException ex)
                {
                    ModelState.AddModelError("", ex.Message);
                }
                catch
                {
                    ModelState.AddModelError("", Resources.IPController.ErrorUpdatingIdentityProvider);
                }
            }

            return View("IP", model);
        }
        public ActionResult Create(IdentityProvider model, IPCertInputModel cert)
        {
            if (cert != null && cert.Cert != null)
            {
                model.IssuerThumbprint = cert.Cert.Thumbprint;
                if (model.IssuerThumbprint != null)
                {
                    ModelState["IssuerThumbprint"].Errors.Clear();
                    ModelState["IssuerThumbprint"].Value = new ValueProviderResult(model.IssuerThumbprint, model.IssuerThumbprint, ModelState["IssuerThumbprint"].Value.Culture);
                }
            }

            if (ModelState.IsValid)
            {
                try
                {
                    this.identityProviderRepository.Add(model);
                    TempData["Message"] = Resources.IPController.IdentityProviderCreated;
                    var config = new AuthConfig();
                    if (model.Type == IdentityProviderTypes.OAuth2)
                    {
                        config.RegisterOauth2IdentityProvider(model);
                    }
                    else if (model.Type == IdentityProviderTypes.OpenId)
                    {
                        config.RegisterOauth2IdentityProvider(model);
                    }
                    return RedirectToAction("IP", new { id = model.ID });
                }
                catch (ValidationException ex)
                {
                    ModelState.AddModelError("", ex.Message);
                }
                catch
                {
                    ModelState.AddModelError("", Resources.IPController.ErrorCreatingIdentityProvider);
                }
            }

            // if we're here, then we should clear name so the view thinks it's new
            model.ID = 0;
            return View("IP", model);
        }