public void PostNewIssueInCacheAndDelete()
        {
            var issue = GetIssue();

            var postTask = new HttpClient().PostAsJsonAsync("{0}/api/1/issue".FormatWith(RavenInstance.Master().ServicesBaseUrl), issue);

            postTask.Wait();
            Assert.That(postTask.Result.StatusCode == HttpStatusCode.Created);

            var task =
                new HttpClient().GetAsync(
                    "{0}/api/1/issue/{1}?applicationId={2}".FormatWith(RavenInstance.Master().ServicesBaseUrl, issue.FriendlyId, issue.ApplicationId));

            task.Wait();
            Assert.That(task.Result.StatusCode == HttpStatusCode.OK);

            string id = "{0}|{1}".FormatWith(issue.FriendlyId, IdHelper.GetFriendlyId(issue.ApplicationId));

            var deleteTask = new HttpClient().DeleteAsync("{0}/api/1/issue/{1}".FormatWith(RavenInstance.Master().ServicesBaseUrl, id));

            deleteTask.Wait();
            Assert.That(deleteTask.Result.StatusCode == HttpStatusCode.NoContent);

            var getTask =
                new HttpClient().GetAsync(
                    "{0}/api/1/issue/{1}?applicationId={2}".FormatWith(RavenInstance.Master().ServicesBaseUrl, issue.Id, issue.ApplicationId));

            getTask.Wait();
            Assert.That(getTask.Result.StatusCode == HttpStatusCode.NotFound);
        }
        public GetOrganisationResponse Invoke(GetOrganisationRequest request)
        {
            Trace("Starting...");

            var organisationId = Organisation.GetId(request.OrganisationId);

            var organisation = Session.MasterRaven
                               .Include <Organisation>(o => o.PaymentPlanId)
                               .Include <Organisation>(o => o.RavenInstanceId)
                               .Load <Organisation>(organisationId);

            if (organisation != null)
            {
                if (organisation.PaymentPlanId != null)
                {
                    organisation.PaymentPlan = MasterLoad <PaymentPlan>(organisation.PaymentPlanId);
                }
                organisation.RavenInstance = MasterLoad <RavenInstance>(organisation.RavenInstanceId);

                if (organisation.RavenInstance == null && organisation.RavenInstanceId == RavenInstance.Master().Id)
                {
                    var ravenInstance = RavenInstance.Master();
                    MasterStore(ravenInstance);
                    organisation.RavenInstance = ravenInstance;
                }
            }

            return(new GetOrganisationResponse
            {
                Organisation = organisation
            });
        }
Exemple #3
0
        public IDocumentStore Create(RavenInstance instance)
        {
            if (!_documentStores.ContainsKey(instance.Id))
            {
                lock (_syncLock)
                {
                    if (!_documentStores.ContainsKey(instance.Id))
                    {
                        var store = new DocumentStore
                        {
                            Conventions =
                            {
                                CustomizeJsonSerializer = ser => ser.TypeNameHandling = TypeNameHandling.All,
                            },
                            ResourceManagerId = _resourceManagerId,
                            EnlistInDistributedTransactions = false,
                        };

                        if (instance.IsMaster)
                        {
                            store.ConnectionStringName = "RavenDB";
                        }
                        else
                        {
                            store.Url = instance.RavenUrl;
                        }

                        store.Initialize();
                        _documentStores.Add(instance.Id, store);
                    }
                }
            }

            return(_documentStores[instance.Id]);
        }
        public void PostNewIssueInCache()
        {
            var issue = GetIssue();

            var postTask = new HttpClient().PostJsonAsync("{0}/api/1/issue".FormatWith(RavenInstance.Master().ServicesBaseUrl), issue);

            postTask.Wait();
            Console.Write(postTask.Result.StatusCode);
            Assert.That(postTask.Result.StatusCode == HttpStatusCode.Created);

            var task =
                new HttpClient().GetAsync(
                    "{0}/api/1/issue/{1}?applicationId={2}".FormatWith(RavenInstance.Master().ServicesBaseUrl, issue.FriendlyId, issue.ApplicationId));

            task.Wait();
            Console.Write(task.Result.StatusCode);
            Assert.That(task.Result.StatusCode == HttpStatusCode.OK);
        }
        public void PutNewIssueInCache()
        {
            var issue = GetIssue();

            var postTask = new HttpClient().PostJsonAsync("{0}/api/1/issue".FormatWith(RavenInstance.Master().ServicesBaseUrl), issue);

            postTask.Wait();

            if (postTask.Result.StatusCode != HttpStatusCode.Created)
            {
                var read = postTask.Result.Content.ReadAsStringAsync();
                read.Wait();
                Console.Write(read.Result);
            }

            Assert.That(postTask.Result.StatusCode == HttpStatusCode.Created);

            issue.LastErrorUtc = DateTime.UtcNow;

            //now update
            var putTask = new HttpClient().PutJsonAsync("{0}/api/1/issue".FormatWith(RavenInstance.Master().ServicesBaseUrl), new[] { issue });

            putTask.Wait();

            Assert.That(putTask.Result.StatusCode == HttpStatusCode.NoContent);

            var task = new HttpClient().GetAsync(
                "{0}/api/1/issue/{1}?applicationId={2}".FormatWith(
                    RavenInstance.Master().ServicesBaseUrl, issue.FriendlyId, issue.ApplicationId));

            task.Wait();

            var readResponseTask = task.Result.Content.ReadAsStringAsync();

            readResponseTask.Wait();
            var retrievedIssue = JsonConvert.DeserializeObject <Issue>(readResponseTask.Result);

            Assert.That(retrievedIssue.LastErrorUtc == issue.LastErrorUtc);
            Assert.That(task.Result.StatusCode == HttpStatusCode.OK);
        }
        public ActionResult SyncIndexes()
        {
            Server.ScriptTimeout = 7200; //timeout in 2 hours

            var masterDocumentStore = _storeFactory.Create(RavenInstance.Master());

            IndexCreation.CreateIndexes(new CompositionContainer(
                                            new AssemblyCatalog(typeof(Issues).Assembly), new ExportProvider[0]),
                                        masterDocumentStore.DatabaseCommands.ForDatabase(CoreConstants.ErrorditeMasterDatabaseName),
                                        masterDocumentStore.Conventions);

            foreach (var organisation in Core.Session.MasterRaven.Query <Organisation>().GetAllItemsAsList(100))
            {
                organisation.RavenInstance = Core.Session.MasterRaven.Load <RavenInstance>(organisation.RavenInstanceId);

                using (_session.SwitchOrg(organisation))
                {
                    _session.BootstrapOrganisation(organisation);
                }
            }

            ConfirmationNotification("All indexes for all organisations have been updated");
            return(RedirectToAction("index"));
        }
        public void Start(string ravenInstanceId)
        {
            Trace("Starting Errordite service {0} for raven instance:={1}", _serviceConfiguration.Service, ravenInstanceId);

            //receive service runs a thread per organisation, polling every org's queue
            //other services just have a single thread processing the queue
            if (_serviceConfiguration.Service == Service.Receive)
            {
                IEnumerable<Organisation> organisations;
                using (ObjectFactory.Container.Kernel.BeginScope())
                {
                    using (var session = ObjectFactory.GetObject<IAppSession>())
                    {
                        organisations = session.MasterRaven
                            .Query<OrganisationDocument, Organisations>()
                            .Where(o => o.RavenInstanceId == RavenInstance.GetId(ravenInstanceId))
							.As<Organisation>()
                            .ToList();
                    }
                }

                foreach (var organisation in organisations)
                {
                    AddProcessor(organisation.FriendlyId, null);
                }
            }
            else
            {
                for (int i = 0; i < _serviceConfiguration.ServiceProcessorCount; i++)
                {
                    AddProcessor(null, ravenInstanceId);
                }
            }

            Trace("Started Errordite service {0} for raven instance:={1}", _serviceConfiguration.Service, ravenInstanceId);
        }
Exemple #8
0
        public CreateOrganisationResponse Invoke(CreateOrganisationRequest request)
        {
            Trace("Starting...");

            var existingOrganisation = Session.MasterRaven
                                       .Query <Organisation, Indexing.Organisations>()
                                       .FirstOrDefault(o => o.Name == request.OrganisationName);

            if (existingOrganisation != null)
            {
                return(new CreateOrganisationResponse
                {
                    Status = CreateOrganisationStatus.OrganisationExists
                });
            }

            var freeTrialPlan = _getAvailablePaymentPlansQuery.Invoke(new GetAvailablePaymentPlansRequest()).Plans.FirstOrDefault(p => p.IsFreeTier);
            var timezone      = request.TimezoneId ?? "UTC";
            var date          = DateTime.UtcNow.ToDateTimeOffset(timezone);

            var organisation = new Organisation
            {
                Name          = request.OrganisationName,
                Status        = OrganisationStatus.Active,
                PaymentPlanId = freeTrialPlan?.Id,
                CreatedOnUtc  = DateTime.UtcNow,
                TimezoneId    = timezone,
                PaymentPlan   = freeTrialPlan,
                ApiKeySalt    = Membership.GeneratePassword(8, 1),
                Subscription  = new Subscription
                {
                    Status               = SubscriptionStatus.Trial,
                    StartDate            = date,
                    CurrentPeriodEndDate = date.AddMonths(1),
                    LastModified         = date
                },
                CallbackUrl = request.CallbackUrl,
            };

            var ravenInstance = _getRavenInstancesQuery.Invoke(new GetRavenInstancesRequest())
                                .RavenInstances
                                .FirstOrDefault(r => r.Active) ?? RavenInstance.Master();

            organisation.RavenInstance   = ravenInstance;
            organisation.RavenInstanceId = ravenInstance.Id;

            MasterStore(organisation);

            var existingUserOrgMap = Session.MasterRaven
                                     .Query <UserOrganisationMapping, UserOrganisationMappings>()
                                     .FirstOrDefault(u => u.EmailAddress == request.Email);

            if (existingUserOrgMap != null)
            {
                existingUserOrgMap.Organisations.Add(organisation.Id);
            }
            else
            {
                MasterStore(new UserOrganisationMapping
                {
                    EmailAddress  = request.Email,
                    Organisations = new List <string> {
                        organisation.Id
                    },
                    Password      = request.Password.Hash(),
                    PasswordToken = Guid.Empty,
                    Status        = UserStatus.Active,
                    SsoUser       = request.SpecialUser.IsIn(SpecialUser.AppHarbor),
                });
            }

            organisation.ApiKey = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(
                    _encryptor.Encrypt("{0}|{1}".FormatWith(organisation.FriendlyId, organisation.ApiKeySalt))));

            Session.SetOrganisation(organisation);
            Session.BootstrapOrganisation(organisation);

            var group = new Group
            {
                Name           = request.OrganisationName,
                OrganisationId = organisation.Id
            };

            Store(group);

            var user = new User
            {
                Email     = request.Email,
                FirstName = request.FirstName,
                LastName  = request.LastName,
                Role      = UserRole.Administrator,
                GroupIds  = new List <string> {
                    group.Id
                },
                ActiveOrganisation = organisation,
                OrganisationId     = organisation.Id,
                SpecialUser        = request.SpecialUser,
            };

            Store(user);

            //update the organisation with the primary user
            organisation.PrimaryUserId = user.Id;

            var addApplicationResponse = _addApplicationCommand.Invoke(new AddApplicationRequest
            {
                CurrentUser        = user,
                IsActive           = true,
                MatchRuleFactoryId = new MethodAndTypeMatchRuleFactory().Id,
                Name = request.OrganisationName,
                NotificationGroups = new List <string> {
                    group.Id
                },
                UserId   = user.Id,
                IsSignUp = true,
            });

            //TODO: sync indexes
            Session.SynchroniseIndexes <Indexing.Organisations, Indexing.Users>();

            return(new CreateOrganisationResponse(request.Email)
            {
                OrganisationId = organisation.Id,
                UserId = user.Id,
                ApplicationId = addApplicationResponse.ApplicationId,
            });
        }
        public void SendErrorsForProcessing()
        {
            var postTask = new HttpClient().PostJsonAsync("{0}/api/1/ReprocessIssueErrors".FormatWith(RavenInstance.Master().ServicesBaseUrl), new ReprocessIssueErrorsRequest
            {
                IssueId        = "issues/1",
                OrganisationId = "organisations/1"
            });

            postTask.Wait();
            Assert.That(postTask.Result.StatusCode == HttpStatusCode.OK);

            var read = postTask.Result.Content.ReadAsStringAsync();

            read.Wait();
            var response = JsonConvert.DeserializeObject <ReprocessIssueErrorsResponse>(read.Result);

            Assert.That(response.Status == ReprocessIssueErrorsStatus.Ok);
        }