Beispiel #1
0
        private void PrepareRecords()
        {
            // for provided user-defined field select an appropriate value
            Func <ResourceId, KeyValuePair <object, FieldPropertyCollection>, bool, KeyValuePair <HrbcField, object> > userFieldDataGenerator = (resource, x, isAlt)
                                                                                                                                                => new KeyValuePair <HrbcField, object>(new HrbcField(resource, x.Value.Name), GetValueForUserField(x.Key.ToString(), isAlt));

            // for provided resource append 2 records with all necessary fields populated
            Func <CreateRecordRequest.IBuilder, ResourceId, CreateRecordRequest.IBuilderWithResource> resourceAppender = (rq, resource)
                                                                                                                         => rq.Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, false))
                                                                                                                                      .Concat(ResourceMandatoryFields[resource](false).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value)))
                                                                                                                                      .Concat(SearchConstants.RequiredFieldTypes.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetFieldValueByFieldType(type, false))))
                                                                                                                                      .Concat(SearchConstants.SystemFieldsValues[resource].Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetFieldValueByFieldType(field.Key, false)))), $"{resource}")
                                                                                                                         .Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, true))
                                                                                                                                 .Concat(ResourceMandatoryFields[resource](true).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value)))
                                                                                                                                 .Concat(SearchConstants.RequiredFieldTypes.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetFieldValueByFieldType(type, true))))
                                                                                                                                 .Concat(SearchConstants.SystemFieldsValues[resource].Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetFieldValueByFieldType(field.Key, true)))), $"{resource} Alt");

            RecordsCreator = new HrbcRecordCreator(() =>
            {
                var request = ResourceRequest.CreateRecords();
                foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None }))
                {
                    request = resourceAppender(request, resource);
                }

                return(request as CreateRecordRequest.IBuilderWithResource);
            });
        }
Beispiel #2
0
        public TestReadInvalidInputUserField() : base()
        {
            // create request
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.File, "API automation test field",
                                           builder => builder.MimeType("image/gif,image/jpeg,image/png,image/bmp,image/x-ms-bmp").Height(50).DisplayType(DisplayType.SearchBoxMultiSelection), $"{resourceId}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2"));
        }
Beispiel #3
0
        public TestSearchCustomField() : base()
        {
            fixedFields = new HrbcFieldReader(new[] { "Client.P_Name", "Resume.P_CurrentSalary" }, new[] { FieldProperty.FieldType, FieldProperty.Min, FieldProperty.Max });

            fixedRecords = new HrbcRecordReader(Enums.ResourceType.Client, new List <ulong> {
                10001
            }, () => FieldCollection.Builder().Append("Client.P_Name", "Client.P_Owner").Build());

            readFields = new HrbcFieldReader(new[] { "Resume.P_CurrentSalary" }, new[] { FieldProperty.Min, FieldProperty.Max });

            updateMinFields = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty((Enums.ResourceType)Enum.Parse(typeof(Enums.ResourceType), test.Parent.Properties.Get("Resource") as string, true), test.Parent.Properties.Get("Field") as string, FieldProperty.Min, data.Arguments[0]) });
            updateMaxFields = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty((Enums.ResourceType)data.Arguments[0], (string)data.Arguments[1], FieldProperty.Max, data.Arguments[2]) });

            customFields = new HrbcFieldCreator(Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>()
                                                .SelectMany(resource => new[]
            {
                new HrbcFieldCreator.FieldSpec {
                    Resource = resource, Key = $"{resource}-1", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 1"
                },
                new HrbcFieldCreator.FieldSpec {
                    Resource = resource, Key = $"{resource}-2", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 2"
                },
                new HrbcFieldCreator.FieldSpec {
                    Resource = resource, Key = $"{resource}-3", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 3"
                }
            }),
                                                new List <FieldProperty> {
                FieldProperty.Name
            });

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client, content => content.Append("P_Name", "Record 1").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 10), "Client 10")
                                            .Append(ResourceId.Client, content => content.Append("P_Name", "Record 2").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 20), "Client 20")
                                            .Append(ResourceId.Client, content => content.Append("P_Name", "Record 3").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 30), "Client 30"));
        }
        public void FixtureSetUp()
        {
            Log.Info("Starting the test of Read Candidate!");
            this.nameKeyword = Util.GetUniqueString(5, false);
            this.memoKeyword = Util.GetUniqueString(5, false);

            var builder = (CreateRecordRequest.IBuilderWithResource)ResourceRequest.CreateRecords();

            for (var i = 0; i < RECORD_NUMBER; i++)
            {
                builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content), i);
            }


            candidateId = (new Random()).Next(RECORD_NUMBER);
            //Prepare data for Wildcard
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content, "Jacky_Nam"), "Jacky_Nam");
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content, "_Jacky Nam"), "_Jacky Nam");
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content, "_Jacky_Nam"), "_Jacky_Nam");
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content, "_Ja_cky Nam"), "_Ja_cky Nam");
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => CreateCandidateContent(content, nameKeyword), nameKeyword);
            builder.Append(HRBCClientPrivate.Common.ResourceId.Person, content => content
                           .Append("P_Owner", "1")
                           .Append("P_Name", "Jacky Nam")
                           .Append("P_Memo", memoKeyword), memoKeyword);

            records = new APITestFramework.PrivateFixtures.HrbcRecordCreator(() => builder);

            //Prepare the past of date time for comparing "gt", "ge", "le", "lt"...
            DateTime time = DateTime.Now;

            time = time.AddDays(2);
            SAMPLE_CANDIDATE_DATETIME = Util.ToString(time);
        }
Beispiel #5
0
        private CreateRecordRequest.IBuilderWithResource InitCreateResourceRequest(int resourceNumber, Func <Enums.ResourceType, IEnumerable <string> > getFieldList)
        {
            Dictionary <Enums.ResourceType, ulong> phaseList = new Dictionary <Enums.ResourceType, ulong>();

            foreach (var resourceType in Enum.GetValues(typeof(Enums.ResourceType)))
            {
                if ((Enums.ResourceType)resourceType != Enums.ResourceType.Contract)
                {
                    phaseList[(Enums.ResourceType)resourceType] =
                        ulong.Parse(OptionFieldHelper.GetOptionItem(OptionFieldHelper.GetOptionList($"Option.P_{((Enums.ResourceType)resourceType).ToResourceName()}Phase").First()).Id);
                }
            }

            CreateRecordRequest.IBuilder result = ResourceRequest.CreateRecords();
            foreach (var symbolType in Enum.GetValues(typeof(SameResultSymbolType)))
            {
                foreach (var resourceType in Enum.GetValues(typeof(Enums.ResourceType)))
                {
                    result.Append(((Enums.ResourceType)resourceType).ToPrivateEnum(),
                                  content =>
                    {
                        AppendCommonContent(content, (SameResultSymbolType)symbolType, (Enums.ResourceType)resourceType, phaseList);
                        foreach (var field in CommonConstant.NoneTelephoneTextField[(Enums.ResourceType)resourceType])
                        {
                            content.Append(field, KeywordHelper.GetFieldValueBasedOnSymbolType(field, (SameResultSymbolType)symbolType, GetSymbolIndex((SameResultSymbolType)symbolType)));
                        }
                        foreach (var field in CommonConstant.ApplicationNoneTelephoneTextField)
                        {
                            content.Append(field, KeywordHelper.GetFieldValueBasedOnSymbolType(field, (SameResultSymbolType)symbolType, GetSymbolIndex((SameResultSymbolType)symbolType)));
                        }
                    }, $"{resourceType}{symbolType}");
                }
            }
            return(result as CreateRecordRequest.IBuilderWithResource);
        }
Beispiel #6
0
        public TestReadOrderFieldUserField() : base()
        {
            InitFieldCreator();

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job3")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume3"));
        }
        private void PrepareRecords()
        {
            // for provided user-defined field select an appropriate value
            Func <ResourceId, KeyValuePair <object, FieldPropertyCollection>, int, KeyValuePair <HrbcField, object> > userFieldDataGenerator = (resource, x, index)
                                                                                                                                               => new KeyValuePair <HrbcField, object>(new HrbcField(resource, x.Value.Name), GetTestDateTime());

            // for provided resource append 2 records with all necessary fields populated
            Func <CreateRecordRequest.IBuilder, ResourceId, int, CreateRecordRequest.IBuilderWithResource> resourceAppender = (rq, resource, index)
                                                                                                                              => rq.Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, index))
                                                                                                                                           .Concat(ResourceMandatoryFields[resource](index).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value)))
                                                                                                                                           .Concat(DateFields.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetTestDateTime())))
                                                                                                                                           .Concat(SearchConstants.SystemFieldsValues[resource].Where(x => DateFields.Contains(x.Key)).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetTestDateTime())))
                                                                                                                                           .Concat(AdditionalFields(resource)), $"{resource}{index}")
            ;

            RecordsCreator = new HrbcRecordCreator(() =>
            {
                var request = ResourceRequest.CreateRecords();

                for (int i = 0; i < NumRecords; i++)
                {
                    foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None }))
                    {
                        request = resourceAppender(request, resource, i);
                    }
                }

                return(request as CreateRecordRequest.IBuilderWithResource);
            });
        }
Beispiel #8
0
        public static CreateRecordRequest.IBuilderWithResource ComposeRequestForAllParameters(Func <OptionDataCollection> processPhaseInfoProvider, int testUserId)
        {
            return(ResourceRequest.CreateRecords()
                   .Append(ResourceId.Client,
                           content => content
                           .Append("P_Name", "Test Client")
                           .Append("P_Owner", testUserId),
                           ResourceId.Client)
                   .Append(ResourceId.Recruiter,
                           content => content
                           .Append("P_Name", "Test Recruiter")
                           .Append("P_Owner", testUserId)
                           .Append("P_Client", new CreateRecordRequest.Reference(ResourceId.Client)),
                           ResourceId.Recruiter)
                   .Append(ResourceId.Job,
                           content => content
                           .Append("P_Position", "Test Job")
                           .Append("P_Owner", testUserId)
                           .Append("P_Client", new CreateRecordRequest.Reference(ResourceId.Client))
                           .Append("P_Recruiter", new CreateRecordRequest.Reference(ResourceId.Recruiter)),
                           ResourceId.Job)
                   .Append(ResourceId.Person,
                           content => content
                           .Append("P_Name", "Test Person")
                           .Append("P_Owner", testUserId),
                           ResourceId.Person)
                   .Append(ResourceId.Resume,
                           content => content
                           .Append("P_Owner", testUserId)
                           .Append("P_Candidate", new CreateRecordRequest.Reference(ResourceId.Person)),
                           ResourceId.Resume)
                   .Append(ResourceId.Process,
                           content => content
                           .Append("P_Owner", testUserId)
                           .Append("P_Client", new CreateRecordRequest.Reference(ResourceId.Client))
                           .Append("P_Recruiter", new CreateRecordRequest.Reference(ResourceId.Recruiter))
                           .Append("P_Job", new CreateRecordRequest.Reference(ResourceId.Job))
                           .Append("P_Candidate", new CreateRecordRequest.Reference(ResourceId.Person))
                           .Append("P_Resume", new CreateRecordRequest.Reference(ResourceId.Resume))
                           .Append("P_Phase", processPhaseInfoProvider()),
                           ResourceId.Process)

                   .Append(ResourceId.Sales,
                           content => content
                           .Append("P_Owner", testUserId),
                           ResourceId.Sales)
                   .Append(ResourceId.Activity,
                           content => content
                           .Append("P_Title", "Test Activity")
                           .Append("P_Owner", testUserId)
                           .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                           ResourceId.Activity)
                   .Append(ResourceId.Contract,
                           content => content
                           .Append("P_Name", "Test Contract")
                           .Append("P_Client", new CreateRecordRequest.Reference(ResourceId.Client)),
                           ResourceId.Contract));
        }
        /// <summary>
        /// Create an instance of CreateRecordRequest.IBuilderWithResource that creates all type of Resources with list of field inputs.
        /// Use $"{ResourceId}{index}" to get the proper record.
        /// </summary>
        /// <param name="resourceNumber">Number of records created</param>
        /// <param name="testCaseData">Dictionary of test case data</param>
        /// <param name="fieldsName">List of field name</param>
        /// <returns>CreateRecordRequest.IBuilderWithResource</returns>
        public static CreateRecordRequest.IBuilderWithResource InitCreateAllResourceRequestWithField(HrbcFieldCreator customField, string[] applicationField)
        {
            CreateRecordRequest.IBuilder result = ResourceRequest.CreateRecords();
            List <string> processPhases         = OptionFieldHelper.GetOptionList(Enums.Options.ProcessPhase);
            Option        option   = OptionFieldHelper.GetOptionItem(processPhases.First());
            ulong         optionId = ulong.Parse(option.Id);

            foreach (var resourceType in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                result.Append(resourceType.ToPrivateEnum(),
                              content => PrepareContent(content, resourceType, customField, applicationField),
                              $"{resourceType.ToPrivateEnum()}");
            }

            return(result as CreateRecordRequest.IBuilderWithResource);
        }
Beispiel #10
0
        private void InitHrbcCreatorRecord()
        {
            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2"));
        }
        private static CreateRecordRequest.IBuilderWithResource InitCreateAllResourceRequestUserField(HrbcFieldCreator customField, int recordNumbers)
        {
            CreateRecordRequest.IBuilder result = ResourceRequest.CreateRecords();

            for (int i = 0; i < recordNumbers; i++)
            {
                for (int j = 0; j < UserKeywordInputs.Count; j++) //Create records for normal and special phone text
                {
                    foreach (var resourceType in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
                    {
                        result.Append(resourceType.ToPrivateEnum(),
                                      content => PrepareUserFieldContent(content, resourceType, customField, i * 2 + j, UserKeywordInputs.ElementAt(j).Value),
                                      $"{resourceType.ToPrivateEnum()}{i}{UserKeywordInputs.ElementAt(j).Key}");
                    }
                }
            }

            return(result as CreateRecordRequest.IBuilderWithResource);
        }
Beispiel #12
0
        public async Task CreateSingleRecordOnServer()
        {
            using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
            {
                ServerUrl = new Uri("http://namtest2-web.dynamic.ps.porters.local"), LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
            }))
                using (var session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password")))
                {
                    var request = ResourceRequest.CreateRecords()
                                  .Append(ResourceId.Recruiter, builder => builder.Append("P_Name", "test record 3").Append("P_Client", new CreateRecordRequest.Reference("key1")).Append("P_Owner", 1), "req1")
                                  .Append(ResourceId.Client, builder => builder.Append("P_Name", "test record").Append("P_Owner", 1), "key1")
                                  .Append(ResourceId.Client, builder => builder.Append("P_Name", "test record 2").Append("P_Owner", 1), "key2")
                                  .Append(ResourceId.Client, builder => builder.Append("P_Name", "test record 3").Append("P_Owner", 1), "key3")
                                  .Build();
                    var response = await session.CallAsync(request);

                    Assert.That(response.Errors, Is.Empty);
                    Assert.That(response.RecordIds, Has.Count.EqualTo(4));
                }
        }
        private CreateRecordRequest.IBuilderWithResource InitCreateResourceRequest(int resourceNumber)
        {
            CreateRecordRequest.IBuilder result = ResourceRequest.CreateRecords();

            foreach (var symbolType in Enum.GetValues(typeof(SameResultSymbolType)))
            {
                foreach (var resourceType in Enum.GetValues(typeof(Enums.ResourceType)))
                {
                    result.Append(((Enums.ResourceType)resourceType).ToPrivateEnum(),
                                  content =>
                    {
                        AppendCommonContent(content, (SameResultSymbolType)symbolType, (Enums.ResourceType)resourceType);
                        foreach (var fieldType in NoneTelephoneTextField)
                        {
                            content.Append(customFields.Data[$"{resourceType}-{fieldType}"].Field.Name,
                                           KeywordHelper.GetFieldValueBasedOnSymbolType(customFields.Data[$"{resourceType}-{fieldType}"].Field.Name,
                                                                                        (SameResultSymbolType)symbolType, GetSymbolIndex((SameResultSymbolType)symbolType)));
                        }
                    }, $"{resourceType}{symbolType}");
                }
            }
            return(result as CreateRecordRequest.IBuilderWithResource);
        }
 private static CreateRecordRequest.IBuilderWithResource InitCreatePhoneResourceRequest(int resourceNumber, Dictionary <object, string> testCaseData)
 {
     CreateRecordRequest.IBuilder result = ResourceRequest.CreateRecords();
     for (int i = 0; i < resourceNumber; i++)
     {
         foreach (var test in testCaseData)
         {
             result
             .Append(ResourceId.Client,
                     content => content
                     .Append("P_Name", "Test Client")
                     .Append(KeywordSystemField.ClientTelephone, test.Value)
                     .Append(KeywordSystemField.ClientFax, test.Value)
                     .Append("P_Owner", DefaultUser),
                     $"{ResourceId.Client}{test.Key}{i}")
             .Append(ResourceId.Recruiter,
                     content => content
                     .Append("P_Name", "Test Recruiter")
                     .Append(KeywordSystemField.RecruiterTelephone, test.Value)
                     .Append(KeywordSystemField.RecruiterFax, test.Value)
                     .Append(KeywordSystemField.RecruiterMobile, test.Value)
                     .Append("P_Owner", DefaultUser)
                     .Append("P_Client", new CreateRecordRequest.Reference($"{ResourceId.Client}{test.Key}{i}")),
                     $"{ResourceId.Recruiter}{test.Key}{i}")
             .Append(ResourceId.Person,
                     content => content
                     .Append("P_Name", "Test Person")
                     .Append(KeywordSystemField.PersonTelephone, test.Value)
                     .Append(KeywordSystemField.PersonFax, test.Value)
                     .Append(KeywordSystemField.PersonMobile, test.Value)
                     .Append("P_Owner", DefaultUser),
                     $"{ResourceId.Person}{test.Key}{i}");
         }
     }
     return(result as CreateRecordRequest.IBuilderWithResource);
 }
Beispiel #15
0
        public TestWriteCustomFieldInvalidInputWithScaleSystemField() : base()
        {
            Dictionary <FieldProperty, object> fieldPropertiesOneScale = new Dictionary <FieldProperty, object> {
                { FieldProperty.Min, -99999999.9m }, { FieldProperty.Max, 9999999999998.9m }, { FieldProperty.Scale, 1 }
            };
            Dictionary <FieldProperty, object> fieldPropertiesTwoScale = new Dictionary <FieldProperty, object> {
                { FieldProperty.Min, -99999999.99m }, { FieldProperty.Max, 9999999999998.99m }, { FieldProperty.Scale, 2 }
            };

            updateFieldsOneScaleContingentFeeRate = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, "P_ContingentFeeRate", fieldPropertiesOneScale) });
            updateFieldsTwoScaleContingentFeeRate = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, "P_ContingentFeeRate", fieldPropertiesTwoScale) });

            updateFieldsOneScaleChangeJobsCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, "P_ChangeJobsCount", fieldPropertiesOneScale) });
            updateFieldsTwoScaleChangeJobsCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, "P_ChangeJobsCount", fieldPropertiesTwoScale) });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestReadValidInputApplicationField() : base()
        {
            List <string> alias = new List <string>()
            {
                OptionCheckBox1,
                OptionCheckBox2,
                OptionDropDown1,
                OptionDropDown2,
                OptionRadioButton1,
                OptionRadioButton2,
                CheckBox1,
                CheckBox2,
                DropDown1,
                DropDown2,
                RadioButton1,
                RadioButton2,
                SearchBox1,
                SearchBox2,
                MultiSearchBox1,
                MultiSearchBox2,
            };

            List <FieldProperty> select = new List <FieldProperty>()
            {
                FieldProperty.OptionMaster
            };

            fieldReader = new HrbcFieldReader(alias, select);

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #17
0
        public TestSearchMultipleFieldConditionApplicationField() : base()
        {
            List <string> applicationField = new List <string> {
            };
            string resourceName            = string.Empty;

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                resourceName = resourceId == Enums.ResourceType.Candidate ? "Person" : resourceId.ToString();
                applicationField.Add(resourceName + "." + AppField1);
                applicationField.Add(resourceName + "." + AppField2);
            }

            readFields = new HrbcFieldReader(applicationField, new[] { FieldProperty.TextLength });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job3")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume3")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #18
0
        public TestWriteDefaultField() : base()
        {
            //Read fields
            List <string> defaultField = new List <string> {
            };

            defaultField.Add($"Contract.{AdvancePayment}");
            defaultField.Add($"Contract.{ContingentFee}");
            defaultField.Add($"Contract.{ContractorFee}");
            defaultField.Add($"Resume.{CurrentSalary}");
            defaultField.Add($"Resume.{ExpectSalary}");
            defaultField.Add($"Resume.{DesiredHourlyRate}");
            defaultField.Add($"Resume.{HourlyRate}");
            defaultField.Add($"Sales.{SalesAmount}");
            defaultField.Add($"Process.{ExpectedSalesAmount}");
            defaultField.Add($"Job.{MinSalary}");
            defaultField.Add($"Job.{MaxSalary}");
            readFields = new HrbcFieldReader(defaultField, new[] { FieldProperty.Min, FieldProperty.Max });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestGeneralFieldSettingValidationUserField() : base()
        {
            // create request
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Required(true), $"{resourceId}-{Required}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Required(false), $"{resourceId}-{NoRequired}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Searchable(true), $"{resourceId}-{Searchable}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Searchable(false), $"{resourceId}-{UnSearchable}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Web(true), $"{resourceId}-{Web}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Web(false), $"{resourceId}-{NoWeb}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Highlight(true), $"{resourceId}-{Document}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Highlight(false), $"{resourceId}-{NoDocument}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Copy(true), $"{resourceId}-{Copy}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                           builder => builder.Copy(false), $"{resourceId}-{NoCopy}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestReadDefaultField() : base()
        {
            //Read fields
            List <string> defaultField = new List <string> {
            };

            defaultField.Add($"Contract.{ContingentFeeRate}");
            defaultField.Add($"Contract.{ContractorHeadCount}");
            defaultField.Add($"Resume.{ChangeJobsCount}");
            readFields = new HrbcFieldReader(defaultField, new[] { FieldProperty.Min, FieldProperty.Max });

            //Update fields
            RandomMin = Util.GetRandomNumber(-999999999, 0).ToString();
            RandomMax = Util.GetRandomNumber(999999999).ToString();

            Dictionary <FieldProperty, object> fieldPropertiesMin = new Dictionary <FieldProperty, object> {
                { FieldProperty.Min, RandomMin }
            };
            Dictionary <FieldProperty, object> fieldPropertiesMax = new Dictionary <FieldProperty, object> {
                { FieldProperty.Max, RandomMax }
            };

            updateFieldsRandomMinContingentFeeRate = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, ContingentFeeRate, fieldPropertiesMin) });
            updateFieldsRandomMaxContingentFeeRate = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, ContingentFeeRate, fieldPropertiesMax) });

            updateFieldsRandomMinContractorHeadCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, ContractorHeadCount, fieldPropertiesMin) });
            updateFieldsRandomMaxContractorHeadCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, ContractorHeadCount, fieldPropertiesMax) });

            updateFieldsRandomMinChangeJobsCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, ChangeJobsCount, fieldPropertiesMin) });
            updateFieldsRandomMaxChangeJobsCount = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, ChangeJobsCount, fieldPropertiesMax) });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestWriteInjectionInputUserField() : base()
        {
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.File, "API automation test field",
                                           builder => builder.Searchable(false)
                                           .MimeType("image/gif,image/jpeg,image/png,image/bmp,image/x-ms-bmp")
                                           .DisplayType(DisplayType.SearchBoxMultiSelection)
                                           .Required(false).Web(false).Highlight(false).Height(50)
                                           , $"{resourceId}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #22
0
        private void InitRecordReader(HrbcOptionReader optionReader)
        {
            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Process,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1"))
                                                    .Append("P_Job", new CreateRecordRequest.Reference("job2"))
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1"))
                                                    .Append("P_Resume", new CreateRecordRequest.Reference("resume2"))
                                                    .Append("P_Phase", optionReader.Data.Single().Key.ToString()),
                                                    "process1")
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestReadEscapeSequencesApplicationField() : base()
        {
            List <FieldProperty> select = new List <FieldProperty>()
            {
                FieldProperty.TextLength
            };

            readFields = new HrbcFieldReader(new List <string> {
                AppField
            }, select);

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #24
0
        public TestReadValidResourceUserFieldWithoutScale() : base()
        {
            Log.Info("Random precision: {0}", randomPrecision);
            decimal temp           = (decimal)(Math.Pow(10, randomPrecision) - 1);
            decimal maxRandomValue = (decimal)Convert.ChangeType((Math.Pow(10, randomPrecision) - 1), typeof(decimal));
            decimal minRandomValue = (-1m) * maxRandomValue;

            Log.Info("Temp: {0}", temp);
            Log.Info("Max random value: {0}", maxRandomValue);
            Log.Info("Min random value: {0}", minRandomValue);

            // create request
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Number, "API automation test field",
                                           builder => builder.Searchable(false).Min(-9m).Max(9m).Required(false).Scale(0), $"{resourceId}-{MinimumPrecision}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Number, "API automation test field",
                                           builder => builder.Searchable(false).Min(-9999999999999.0m).Max(9999999999999.0m).Required(false).Scale(0), $"{resourceId}-{MaximumPrecision}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Number, "API automation test field",
                                           builder => builder.Searchable(false).Min(minRandomValue).Max(maxRandomValue).Required(false).Scale(0), $"{resourceId}-{RandomPrecision}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestGeneralFieldSettingValidationSystemField() : base()
        {
            updateFieldsRequiredContract = new HrbcFieldUpdater((test, data) =>
                                                                new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                               new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Required, true }
                }) });

            updateFieldsNoRequiredContract = new HrbcFieldUpdater((test, data) =>
                                                                  new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                                 new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Required, false }
                }) });

            updateFieldsSearchableContract = new HrbcFieldUpdater((test, data) =>
                                                                  new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                                 new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Searchable, true }
                }) });

            updateFieldsUnSearchableContract = new HrbcFieldUpdater((test, data) =>
                                                                    new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                                   new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Searchable, false }
                }) });

            updateFieldsWebContract = new HrbcFieldUpdater((test, data) =>
                                                           new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                          new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Web, true }
                }) });

            updateFieldsNoWebContract = new HrbcFieldUpdater((test, data) =>
                                                             new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                            new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Web, false }
                }) });

            updateFieldsDocumentContract = new HrbcFieldUpdater((test, data) =>
                                                                new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                               new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Highlight, true }
                }) });

            updateFieldsNoDocumentContract = new HrbcFieldUpdater((test, data) =>
                                                                  new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                                 new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Highlight, false }
                }) });

            updateFieldsCopyContract = new HrbcFieldUpdater((test, data) =>
                                                            new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                           new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Copy, true }
                }) });

            updateFieldsNoCopyContract = new HrbcFieldUpdater((test, data) =>
                                                              new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Contract, SystemFieldContract,
                                                                                                             new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Copy, false }
                }) });

            //
            updateFieldsRequiredResume = new HrbcFieldUpdater((test, data) =>
                                                              new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                             new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Required, true }
                }) });

            updateFieldsNoRequiredResume = new HrbcFieldUpdater((test, data) =>
                                                                new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                               new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Required, false }
                }) });

            updateFieldsSearchableResume = new HrbcFieldUpdater((test, data) =>
                                                                new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                               new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Searchable, true }
                }) });

            updateFieldsUnSearchableResume = new HrbcFieldUpdater((test, data) =>
                                                                  new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                                 new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Searchable, false }
                }) });

            updateFieldsWebResume = new HrbcFieldUpdater((test, data) =>
                                                         new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                        new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Web, true }
                }) });

            updateFieldsNoWebResume = new HrbcFieldUpdater((test, data) =>
                                                           new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                          new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Web, false }
                }) });

            updateFieldsDocumentResume = new HrbcFieldUpdater((test, data) =>
                                                              new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                             new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Highlight, true }
                }) });

            updateFieldsNoDocumentResume = new HrbcFieldUpdater((test, data) =>
                                                                new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                               new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Highlight, false }
                }) });

            updateFieldsCopyResume = new HrbcFieldUpdater((test, data) =>
                                                          new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                         new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Copy, true }
                }) });

            updateFieldsNoCopyResume = new HrbcFieldUpdater((test, data) =>
                                                            new[] { CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType.Resume, SystemFieldResume,
                                                                                                           new Dictionary <FieldProperty, object> {
                    { FieldProperty.Min, Min }, { FieldProperty.Max, Max }, { FieldProperty.Copy, false }
                }) });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        private void InitRecordCreator()
        {
            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #27
0
        public TestSearchUserField() : base()
        {
            InitFieldCreator();

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job3")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume3")
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestMultipleSearchConditionOneFieldSystemField() : base()
        {
            List <string> alias = new List <string>()
            {
                ClientField,
                ActivityField,
                JobField,
                ResumeField,
                ContractField,
                CandidateField,
                RecruiterField,
                SalesField,
                ProcessField,
            };

            List <FieldProperty> select = new List <FieldProperty>()
            {
                FieldProperty.OptionMaster
            };

            fieldReader = new HrbcFieldReader(alias, select);

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job3")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume3")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
Beispiel #29
0
        public TestWriteCustomFieldInvalidInputWithScaleUserField() : base()
        {
            // create request
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Currency, "API automation test field",
                                           builder => builder.Searchable(false).Min(-99999999.9m).Max(9999999999998.9m).Required(false).Scale(1), $"{resourceId}-{OneScale}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Currency, "API automation test field",
                                           builder => builder.Searchable(false).Min(-99999999.99m).Max(9999999999998.99m).Required(false).Scale(2), $"{resourceId}-{TwoScale}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }
        public TestReadOrderFieldSystemField() : base()
        {
            List <string> alias = new List <string>()
            {
                PhaseField,
                ActivityEventResources,
                //ClientServiceType,
                //ClientType,
                ContractorType,
                //JobServiceType,
                JobPublish,
                JobEmploymentType,
                JobIndustry,
                JobArea,
                JobCategory,
                JobExpectedAgeReason,
                JobPubliclyTraded,
                ProcessClose,
                ProcessCloseReason,
                //ResumeServiceType,
                //ResumeEmploymentType,
                ResumeExperiencedIndustry,
                ResumeCurrentStatus,
                ResumeExperiencedJobCategory,
                ResumeExpectIndustry,
                ResumeExpectJobCategory,
                ResumeExpectEmploymentType,
                ResumeExpectArea,
                ResumeRegisterChannel,
                ResumeGender,
            };

            List <FieldProperty> select = new List <FieldProperty>()
            {
                FieldProperty.OptionMaster
            };

            fieldReader = new HrbcFieldReader(alias, select);

            int testUser = 1;

            records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords()
                                            .Append(ResourceId.Client,
                                                    content => content
                                                    .Append("P_Name", "Test Client")
                                                    .Append("P_Owner", testUser),
                                                    "client1")
                                            .Append(ResourceId.Recruiter,
                                                    content => content
                                                    .Append("P_Name", "Test Recruiter")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "recruiter1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job1")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job2")
                                            .Append(ResourceId.Job,
                                                    content => content
                                                    .Append("P_Position", "Test Job")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1"))
                                                    .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")),
                                                    "job3")
                                            .Append(ResourceId.Person,
                                                    content => content
                                                    .Append("P_Name", "Test Person")
                                                    .Append("P_Owner", testUser),
                                                    "person1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume1")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume2")
                                            .Append(ResourceId.Resume,
                                                    content => content
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_Candidate", new CreateRecordRequest.Reference("person1")),
                                                    "resume3")

                                            /* Example of a progress element:
                                             *               .Append(ResourceId.Process,
                                             *                  content => content
                                             *                      .Append("P_Owner", testUser)
                                             *                      .Append("P_Client", new CreateRecordRequest.Reference("client"))
                                             *                      .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter"))
                                             *                      .Append("P_Job", new CreateRecordRequest.Reference("job"))
                                             *                      .Append("P_Candidate", new CreateRecordRequest.Reference("person"))
                                             *                      .Append("P_Resume", new CreateRecordRequest.Reference("resume")),
                                             *                  "process")
                                             */
                                            .Append(ResourceId.Sales,
                                                    content => content
                                                    //.Append("P_SalesAmount", 5000)
                                                    .Append("P_Owner", testUser),
                                                    "sales1")
                                            .Append(ResourceId.Activity,
                                                    content => content
                                                    .Append("P_Title", "Test Activity")
                                                    .Append("P_Owner", testUser)
                                                    .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                                                    "activity1")
                                            .Append(ResourceId.Contract,
                                                    content => content
                                                    .Append("P_Name", "Test Contract")
                                                    //.Append("P_Owner", testUser)
                                                    .Append("P_Client", new CreateRecordRequest.Reference("client1")),
                                                    "contract1"));
        }