// DELETE: api/Approver/5
        public IHttpActionResult Delete(int id)
        {
            Approver result     = ApproverList.Where(p => p.ID == id).FirstOrDefault();
            var      resultflag = ApproverList.Remove(result);

            return(Ok(resultflag));
        }
    public void Defaults()
    {
        var result = SettingsAttributeReader.ReadFromAttribute(null);

        Assert.IsNotNull(result);
        Approver.Verify(result);
    }
    public void NonDefaults()
    {
        var result = SettingsAttributeReader.ReadFromAttribute(
            new CustomAttributeMock(
                new Dictionary <string, object>
        {
            {
                "ScriptPromotionPath", @"D:\scripts"
            },
            {
                "MsSqlServerScripts", true
            },
            {
                "MySqlScripts", true
            },
            {
                "OracleScripts", true
            },
            {
                "ProduceSagaScripts", false
            },
            {
                "ProduceTimeoutScripts", false
            },
            {
                "ProduceSubscriptionScripts", false
            },
            {
                "ProduceOutboxScripts", false
            }
        }));

        Assert.IsNotNull(result);
        Approver.Verify(result);
    }
Beispiel #4
0
        public Leave Approve(Approver nextApprover)
        {
            Status   = Status.APPROVED;
            Approver = nextApprover;

            return(this);
        }
        public void process(string dp)
        {
            Approver emp = model.Approvers.Where(x => x.Department_ID == dp && x.Status == "Active").FirstOrDefault();

            emp.Status = "Inactive";
            model.SaveChanges();
        }
Beispiel #6
0
        /// <summary>
        /// 向上移动
        /// </summary>
        /// <param name="Order"></param>
        /// <param name="Orders"></param>
        /// <returns></returns>
        public ActionResult ApproverMove(string Id, string Orders, string ProcessItemId)
        {
            Guid Aid = new Guid(Id);
            //根据该字段的id找到order
            Approver a = new Approver();

            a = (from aps in db.Approver
                 where (aps.Id == new Guid(Id))
                 select aps).Single();

            //第二个表的查询
            int      Orde = Convert.ToInt32(Orders);
            Approver b    = new Approver();

            b = (from aps in db.Approver
                 where (aps.Order == Orde && aps.ProcessItemId == new Guid(ProcessItemId)) select aps).Single();

            a.Order           = a.Order - 1;
            db.Entry(a).State = EntityState.Modified;
            b.Order           = b.Order + 1;
            db.Entry(b).State = EntityState.Modified;
            //2.保存到数据库
            int i = db.SaveChanges();

            return(Json(i, JsonRequestBehavior.AllowGet));
        }
Beispiel #7
0
        public void RunMapReduce()
        {
            using (var store = InMemoryStoreBuilder.GetInMemoryStore())
            {
                store.ExecuteIndex(new SagaListIndex());
                using (var session = store.OpenSession())
                {
                    foreach (var sagaHistory in GetFakeHistory())
                    {
                        session.Store(sagaHistory);
                    }

                    session.SaveChanges();
                }

                store.WaitForIndexing();

                using (var session = store.OpenSession())
                {
                    var mapReduceResults = session.Query <SagaListIndex.Result, SagaListIndex>()
                                           .ToList();
                    Approver.Verify(mapReduceResults);
                }
            }
        }
        public async Task <IActionResult> Edit(int CaseID, string LocalUserID, [Bind("CaseID,LocalUserID,Approved,Order,LocalGroupID")] Approver approver)
        {
            if (CaseID != approver.CaseID || LocalUserID != approver.LocalUserID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(approver);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ApproverExists(approver.CaseID, approver.LocalUserID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["CaseID"]       = new SelectList(_context.Case, "CaseID", "CaseID", approver.CaseID);
            ViewData["LocalUserID"]  = new SelectList(_context.LocalUser, "LocalUserID", "LocalUserID", approver.LocalUserID);
            ViewData["LocalGroupID"] = new SelectList(_context.LocalGroup, "LocalGroupID", "LocalGroupID", approver.LocalGroupID);
            return(View(approver));
        }
Beispiel #9
0
 public bool AddApproverForDepartment(int idEmployee, int idDepartment, int approveNumber)
 {
     using (var db = new KadrDataContext())
     {
         try
         {
             var currentApprover =
                 db.Approver.Where(
                     f =>
                     f.idDepartment == idDepartment & f.ApproverType.ApproveNumber == approveNumber &
                     f.DateEnd == null).ToArray();
             foreach (var approver in currentApprover)
             {
                 approver.DateEnd = DateTime.Now;
             }
             var newApprover = new Approver
             {
                 idApproverType =
                     db.ApproverType.Where(w => w.ApproveNumber == approveNumber).Select(
                         s => s.id).FirstOrDefault(),
                 idDepartment = idDepartment,
                 idEmployee   = idEmployee,
                 DateBegin    = DateTime.Now,
                 DateEnd      = null
             };
             db.Approver.InsertOnSubmit(newApprover);
             db.SubmitChanges();
             return(true);
         }
         catch (System.Exception)
         {
             return(false);
         }
     }
 }
Beispiel #10
0
        public IApprover AddApprover(int clientId, int approverId, bool isPrimary)
        {
            Approver appr = new Approver {
                ClientID = clientId, ApproverID = approverId
            };
            Approver existing = Session.Get <Approver>(appr);

            IApprover result;

            if (existing == null)
            {
                appr.Active = true;
                Session.Save(appr);
                SetPrimary(appr, isPrimary);
                result = appr.CreateModel <IApprover>();
            }
            else
            {
                existing.Active = true;
                SetPrimary(existing, isPrimary);
                result = existing.CreateModel <IApprover>();
            }

            return(result);
        }
    public virtual void SaveWithWeirdCharacters()
    {
        var endpointName = nameof(SaveWithWeirdCharacters);
        var definition   = new SagaDefinition(
            tableSuffix: "SagaWithWeirdCharactersಠ_ಠ",
            name: "SagaWithWeirdCharactersಠ_ಠ",
            correlationProperty: new CorrelationProperty
            (
                name: "SimplePropertyಠ_ಠ",
                type: CorrelationPropertyType.String
            )
            );

        var execute = new TestDelegate(() =>
        {
            DropAndCreate(definition, endpointName, schema);
            var id     = Guid.NewGuid();
            var result = SaveWeirdAsync(id, endpointName).GetAwaiter().GetResult();
            Assert.IsNotNull(result);
            Approver.Verify(result, s => s.Replace(id.ToString(), "theSagaId"));
        });

        if (SupportsUnicodeIdentifiers)
        {
            execute();
        }
        else
        {
            Assert.Throws <Exception>(execute);
        }
    }
Beispiel #12
0
        public void PlatformSampleSettings()
        {
            //HINT: Particular.PlatformSample includes a parameterized version of the ServiceControl.exe.config file.
            //If any changes have been made to settings, this may break the embedded config in that project, which may need to be updated.

            Approver.Verify(new Settings());
        }
Beispiel #13
0
        public async Task ShouldNotCacheContext()
        {
            var stringWriter = new StringWriter();

            var pipelineModifications = new PipelineModifications();

            pipelineModifications.Additions.Add(new Behavior1.Registration(stringWriter));
            pipelineModifications.Additions.Add(new Stage1.Registration(stringWriter));
            pipelineModifications.Additions.Add(new Behavior2.Registration(stringWriter));
            pipelineModifications.Additions.Add(new StageFork.Registration(stringWriter));
            pipelineModifications.Additions.Add(new Stage2.Registration(stringWriter));
            pipelineModifications.Additions.Add(new Terminator.Registration(stringWriter));

            var pipeline = new Pipeline <ITransportReceiveContext>(new FakeBuilder(), pipelineModifications);

            stringWriter.WriteLine("Run 1");

            var context = new TestableTransportReceiveContext();

            context.Extensions.Set <IPipelineCache>(new FakePipelineCache());
            context.Extensions.Set(ExtendableExtensions.RunSpecificKey, 1);

            await pipeline.Invoke(context);

            stringWriter.WriteLine("Run 2");

            context = new TestableTransportReceiveContext();
            context.Extensions.Set <IPipelineCache>(new FakePipelineCache());
            context.Extensions.Set(ExtendableExtensions.RunSpecificKey, 2);

            await pipeline.Invoke(context);

            Approver.Verify(stringWriter.ToString());
        }
        public void Print_ShouldPrettifyEscapedStrings()
        {
            var json       = @"{""PrerequisiteStatus"": {""IsSatisfied"": false, ""Reasons"": [""Because some \""escaped\"" json content""]}}";
            var prettified = JsonPrettyPrinter.Print(json);

            Approver.Verify(prettified);
        }
        public void Print_ShouldPrettifyJsonContent()
        {
            var json       = @"{""Container"":{""Type"":""NServiceBus.CommonObjectBuilder""}}";
            var prettified = JsonPrettyPrinter.Print(json);

            Approver.Verify(prettified);
        }
Beispiel #16
0
        public static void Verify(IApprovalWriter writer, IApprovalNamer namer, IApprovalFailureReporter reporter)
        {
            var normalizeLineEndingsForTextFiles = CurrentCaller.GetFirstFrameForAttribute <IgnoreLineEndingsAttribute>();
            var shouldIgnoreLineEndings          = normalizeLineEndingsForTextFiles == null || normalizeLineEndingsForTextFiles.IgnoreLineEndings;

            Approver.Verify(new FileApprover(writer, namer, shouldIgnoreLineEndings), reporter);
        }
        public void Should_have_all_relevant_extraction_apis_exposed()
        {
            var transactionInformationConfigurationMethods = typeof(TransactionInformationConfiguration)
                                                             .GetMethods(BindingFlags.Public | BindingFlags.Instance)
                                                             .Where(m => m.Name.StartsWith("Extract"))
                                                             .OrderBy(m => m.Name)
                                                             .ThenBy(m => m.GetParameters().Length)
                                                             .Select(m => m.ToString());

            var containerInformationExtractorMethods = typeof(ContainerInformationExtractor)
                                                       .GetMethods(BindingFlags.Public | BindingFlags.Instance)
                                                       .Where(m => m.Name.StartsWith("Extract"))
                                                       .OrderBy(m => m.Name)
                                                       .ThenBy(m => m.GetParameters().Length)
                                                       .Select(m => m.ToString());

            var partitionKeyExtractorMethods = typeof(PartitionKeyExtractor)
                                               .GetMethods(BindingFlags.Public | BindingFlags.Instance)
                                               .Where(m => m.Name.StartsWith("Extract"))
                                               .OrderBy(m => m.Name)
                                               .ThenBy(m => m.GetParameters().Length)
                                               .Select(m => m.ToString());

            // represents the missing extraction methods in the TransactionInformationConfiguration object
            var methodInfos = containerInformationExtractorMethods.Union(partitionKeyExtractorMethods).Except(transactionInformationConfigurationMethods)
                              .Distinct()
                              .ToArray();

            Approver.Verify(methodInfos.Length == 0 ?
                            "Represents the missing extraction methods in the TransactionInformationConfiguration object and should remain empty" :
                            string.Join(Environment.NewLine, methodInfos));
        }
    public void ToSerializable()
    {
        var operations = new List <TransportOperation>
        {
            new TransportOperation(
                messageId: "Id1",
                properties: new DispatchProperties(new Dictionary <string, string>
            {
                {
                    "OptionKey1", "OptionValue1"
                }
            }),
                body: new byte[] { 0x20, 0x21 },
                headers: new Dictionary <string, string>
            {
                {
                    "HeaderKey1", "HeaderValue1"
                }
            }
                )
        };
        var serializableOperations = operations.ToSerializable();

        Approver.Verify(serializableOperations);
    }
    public void IntegrationTest()
    {
        var testDirectory = TestContext.CurrentContext.TestDirectory;
        var temp          = Path.Combine(testDirectory, "InnerTaskTemp");

        if (!Directory.Exists(temp))
        {
            return;
        }
        Directory.Delete(temp, true);
        var intermediatePath = Path.Combine(temp, "IntermediatePath");

        Directory.CreateDirectory(temp);
        Directory.CreateDirectory(intermediatePath);

        var innerTask = new InnerTask(
            assemblyPath: Path.Combine(testDirectory, "ScriptBuilderTask.Tests.Target.dll"),
            intermediateDirectory: intermediatePath,
            projectDirectory: "TheProjectDir",
            solutionDirectory: Path.Combine(temp, "PromotePath"),
            logError: (error, s1) => throw new Exception(error));

        innerTask.Execute();
        var files = Directory.EnumerateFiles(temp, "*.*", SearchOption.AllDirectories).Select(s => s.Replace(temp, "temp")).ToList();

        Assert.IsNotEmpty(files);

        Approver.Verify(files);
    }
    public void UpdateWithTransitional()
    {
        var endpointName = nameof(UpdateWithTransitional);
        var definition   = new SagaDefinition(
            tableSuffix: "CorrAndTransitionalSaga",
            name: "CorrAndTransitionalSaga",
            correlationProperty: new CorrelationProperty
            (
                name: "CorrelationProperty",
                type: CorrelationPropertyType.String
            ),
            transitionalCorrelationProperty: new CorrelationProperty
            (
                name: "TransitionalCorrelationProperty",
                type: CorrelationPropertyType.String
            )
            );

        DropAndCreate(definition, endpointName, schema);
        var id        = Guid.NewGuid();
        var sagaData1 = new CorrAndTransitionalSaga.SagaData
        {
            Id = id,
            CorrelationProperty             = "theCorrelationProperty",
            TransitionalCorrelationProperty = "theTransitionalCorrelationProperty",
            OriginalMessageId = "theOriginalMessageId",
            Originator        = "theOriginator",
            SimpleProperty    = "PropertyValue"
        };

        var persister = SetUp(endpointName, schema);

        using (var connection = dbConnection())
            using (var transaction = connection.BeginTransaction())
                using (var storageSession = new StorageSession(connection, transaction, true, null))
                {
                    persister.Save(sagaData1, storageSession, "theProperty").GetAwaiter().GetResult();
                    storageSession.CompleteAsync().GetAwaiter().GetResult();
                }

        using (var connection = dbConnection())
            using (var transaction = connection.BeginTransaction())
                using (var storageSession = new StorageSession(connection, transaction, true, null))
                {
                    var sagaData = persister.Get <CorrAndTransitionalSaga.SagaData>(id, storageSession).GetAwaiter().GetResult();
                    sagaData.Data.SimpleProperty = "UpdatedValue";
                    persister.Update(sagaData.Data, storageSession, sagaData.Version).GetAwaiter().GetResult();
                    storageSession.CompleteAsync().GetAwaiter().GetResult();
                }

        using (var connection = dbConnection())
            using (var transaction = connection.BeginTransaction())
                using (var storageSession = new StorageSession(connection, transaction, true, null))
                {
                    var sagaData = persister.Get <CorrAndTransitionalSaga.SagaData>(id, storageSession).GetAwaiter().GetResult();
                    Assert.IsNotNull(sagaData);
                    Approver.Verify(sagaData, s => s.Replace(id.ToString(), "theSagaId"));
                    Assert.AreEqual(2, sagaData.Version);
                }
    }
Beispiel #21
0
        private void SetPrimary(Approver appr, bool isPrimary)
        {
            var query = Session.Query <Approver>().Where(x => x.ClientID == appr.ClientID);

            if (isPrimary)
            {
                foreach (Approver item in query)
                {
                    if (item.ApproverID == appr.ApproverID)
                    {
                        item.IsPrimary = true;
                    }
                    else
                    {
                        item.IsPrimary = false;
                    }

                    Session.Update(item);
                }
            }
            else
            {
                appr.IsPrimary = false;
                Session.Update(appr);
            }
        }
Beispiel #22
0
 public async Task SubmitApproval(Leave leave)
 {
     var approver = _personDomainService.FindNextApprover(
         leave.Approver.PersonId,
         leave.LeaderMaxLevel);
     await _leaveDomainService.SubmitApproval(leave, Approver.FromPerson(approver));
 }
        public async Task Make_sure_things_are_in_DI()
        {
            await Scenario.Define <Context>()
            .WithEndpoint <StartedEndpoint>(b => b.When(e => e.SendLocal(new SomeMessage())))
            .Done(c => c.GotTheMessage)
            .Run();

            var builder        = new StringBuilder();
            var coreComponents = spyContainer.RegisteredComponents.Values
                                 .Where(c => c.Type.Assembly == typeof(IMessage).Assembly)
                                 .OrderBy(c => c.Type.FullName)
                                 .ToList();

            builder.AppendLine("----------- Used registrations (Find ways to stop accessing them)-----------");

            foreach (var component in coreComponents.Where(c => c.WasResolved))
            {
                builder.AppendLine(component.ToString());
            }

            builder.AppendLine("----------- Registrations not used by the core, can be removed in next major if downstreams have been confirmed to not use it -----------");

            foreach (var component in coreComponents.Where(c => !c.WasResolved))
            {
                builder.AppendLine(component.ToString());
            }

            Approver.Verify(builder.ToString());
        }
Beispiel #24
0
        public ActionResult GetStaffByFL(ApproverModel model)
        {
            ApproverModel approver = new ApproverModel();
            string        viewName = "CreateApprover";

            if (!model.Id.Equals(Guid.Empty))
            {
                Approver entityApprover = staffService.GetApproverById(model.Id);
                approver = ApproverExtension.ToModel(entityApprover);
                viewName = "EditApprover";
            }
            UserSession.CurrentSession.ProjectDonorId = (Guid)model.ProjectDonorId;
            List <FinanceLimit> financeLimits = budgetService.GetFinanceLimits(countryProg.Id);
            Guid             flId             = model.FinancialLimitId != null ? (Guid)model.FinancialLimitId : Guid.Empty;
            List <StaffView> staffList        = (model.ActivityCode != NotificationHelper.grnCode && model.ActivityCode != NotificationHelper.wrnCode) ?
                                                staffService.GetStaffByFinanceLimit(flId, countryProg.Id) : staffService.GetStaffByCountryProgramme(countryProg.Id);

            approver.FinancialLimitId = model.FinancialLimitId;
            approver.ActivityCode     = model.ActivityCode;
            approver.ActionType       = model.ActionType;
            approver.ActionTypes      = new SelectList(SCMS.CoreBusinessLogic.NotificationsManager.NotificationHelper.GetActionType(model.ActivityCode), "Name", "Name");
            approver.FinancialLimits  = new SelectList(financeLimits, "Id", "Name", model.FinancialLimitId);
            approver.SystemUsers      = new SelectList(staffList, "Id", "StaffName");
            approver.DocumentTypes    = new SelectList(SCMS.CoreBusinessLogic.NotificationsManager.NotificationHelper.GetDocumentTypes4Project(), "DocumentCode", "DocumentName");
            ViewBag.Unlimited         = FinanceLimitUlimited(flId, financeLimits);

            return(View(viewName, approver));
        }
Beispiel #25
0
    public void GetSubscribers()
    {
        var timeoutCommands = SubscriptionCommandBuilder.Build(sqlDialect, "TheTablePrefix");

        // TODO: Not much point validating a type name
        Approver.Verify(timeoutCommands.GetSubscribers.ToString(), scenario: GetType().Name);
    }
Beispiel #26
0
    public void GetNextChunk()
    {
        var startSlice   = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc);
        var timeout1Time = startSlice.AddSeconds(1);
        var timeout2Time = goodUtcNowValue.AddSeconds(10);
        var timeout1     = new TimeoutData
        {
            Destination = "theDestination",
            State       = new byte[] { 1 },
            Time        = timeout1Time,
            Headers     = new Dictionary <string, string>()
        };
        var timeout2 = new TimeoutData
        {
            Destination = "theDestination",
            State       = new byte[] { 1 },
            Time        = timeout2Time,
            Headers     = new Dictionary <string, string>()
        };
        var persister = Setup(schema);

        persister.Add(timeout1, null).Await();
        persister.Add(timeout2, null).Await();
        var nextChunk = persister.GetNextChunk(startSlice).Result;

        Assert.That(nextChunk.NextTimeToQuery, Is.EqualTo(timeout2Time).Within(TimeSpan.FromSeconds(1)));
        Assert.IsNotNull(nextChunk);
        Assert.AreEqual(DateTimeKind.Utc, nextChunk.NextTimeToQuery.Kind);
        Approver.Verify(nextChunk, s => s.Replace(timeout1.Id, "theId"));
    }
    public void WithTransitionalAndNoCorrelation()
    {
        var errorsException = Assert.Throws <ErrorsException>(() => SagaDefinitionValidator.ValidateSagaDefinition(null, "saga1", "Transitional", "tableSuffix"));

        Assert.IsNotNull(errorsException.Message);
        Approver.Verify(errorsException.Message);
    }
    private void TestSagaDefinition <TSagaType>(ModuleDefinition moduleToUse = null)
    {
        moduleToUse = moduleToUse ?? module;

        var dataType     = moduleToUse.GetTypeDefinition <TSagaType>();
        var instructions = InstructionAnalyzer.GetConfigureHowToFindSagaInstructions(dataType);

        var results = new SagaInspectionResults
        {
            HasUnmanagedCalls  = InstructionAnalyzer.CallsUnmanagedMethods(instructions),
            HasUnexpectedCalls = InstructionAnalyzer.CallsUnexpectedMethods(instructions),
            HasBranchingLogic  = InstructionAnalyzer.ContainsBranchingLogic(instructions)
        };

        try
        {
            SagaDefinitionReader.TryGetSagaDefinition(dataType, out results.SagaDefinition);
        }
        catch (Exception x)
        {
            results.Exception = x.Message;
        }

        Approver.Verify(results);
    }
Beispiel #29
0
        public override void MakeLeaveDayRequest(DayStatus dayStatus)
        {
            var leaveDay = new LeaveDay(dayStatus, this);

            History.Add(leaveDay.DeepClone());
            Approver.Approve(leaveDay);
        }
        public void Print_ShouldPrettifyCollections()
        {
            var json       = @"{""Dependencies"":[""RootFeature"",""DelayedDeliveryFeature""],""StartupTasks"":[]}";
            var prettified = JsonPrettyPrinter.Print(json);

            Approver.Verify(prettified);
        }
 public void SetSuccessor(Approver successor)
 {
     this.Successor = successor;
 }
Beispiel #32
0
 public void SetSuccessor(Approver approver)
 {
     this.Successor = approver;
 }