Beispiel #1
0
        private void InitFieldCreator()
        {
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                foreach (var fieldType in KeywordHelper.KeywordTextField)
                {
                    fieldRequestBuilder.Append((ResourceId)(int)resourceId, fieldType, "API automation test field",
                                               builder => builder.Required(false), $"{resourceId}-{fieldType}");
                }
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
        private void PrepareFieldData()
        {
            //Prepare 200 fields in DB
            int fieldNum        = 200;
            int fieldCreatedNum = 0;

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

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                Dictionary <string, object> parameters = new Dictionary <string, object>()
                {
                    { FieldApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
                    { FieldApiFields.Resource, (int)resourceId },
                };

                ReadResponseData <Field> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
                Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Field"));
                int total = result.Total;

                if (total < fieldNum)
                {
                    fieldCreatedNum = fieldNum - total;
                }
                else
                {
                    fieldCreatedNum = 3; // In case of there are more than 200 fields in DB. Create more 3 records for activate 0 checks
                }

                for (int i = 1; i <= fieldCreatedNum; i++)
                {
                    fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, "API automation test field",
                                               builder => builder.Searchable(false).Required(false).TextLength(50), $"{resourceId}-{i}");
                }
                customsFieldForActivate0Nums[resourceId] = fieldCreatedNum;
            }

            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
Beispiel #3
0
        private void InitFieldCreator()
        {
            var        fieldRequestBuilder = FieldRequest.CreateFields();
            ResourceId resourceId          = ResourceType.ToPrivateEnum();

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.SingleLineText, Caption,
                                       builder => builder.Searchable(false).Required(false).TextLength(50), $"{resourceId}-{(SingleLineText)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.MultiLinesText, Caption,
                                       builder => builder.Searchable(false).Required(false).TextLength(50), $"{resourceId}-{(MultipleLineText)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Number, Caption,
                                       builder => builder.Searchable(false).Min(-99999999m).Max(999999999m).Required(false).Scale(0), $"{resourceId}-{(Number)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Currency, Caption,
                                       builder => builder.Searchable(false).Min(-99999999m).Max(999999999m).Required(false).Scale(0), $"{resourceId}-{(Currency)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Date, Caption,
                                       builder => builder.Required(false), $"{resourceId}-{(Date)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Age, Caption,
                                       builder => builder.Required(false), $"{resourceId}-{(Age)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Url, Caption,
                                       builder => builder.Searchable(false).Required(false), $"{resourceId}-{(Url)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Mail, Caption,
                                       builder => builder.Searchable(false).Required(false), $"{resourceId}-{(Mail)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.DateTime, Caption,
                                       builder => builder.Required(false), $"{resourceId}-{(DateTime)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Telephone, Caption,
                                       builder => builder.Searchable(false).Required(false), $"{resourceId}-{(Telephone)}");

            fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.File, Caption,
                                       builder => builder.Searchable(false).Required(false).MimeType("image/gif,image/jpeg,image/png,image/bmp,image/x-ms-bmp").Height(50).DisplayType(DisplayType.SearchBoxMultiSelection), $"{resourceId}-{(Image)}");

            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
        private void PrepareFields()
        {
            var request = FieldRequest.CreateFields();

            var fieldList = new List <HrbcFieldCreator.FieldSpec>();

            foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None }))
            {
                foreach (var fieldType in SearchConstants.RequiredFieldTypes.Except(new[] { TestCoreFramework.Enums.FieldType.OptionCheckbox }))
                {
                    request.Append(CreateFieldRequest.Builder().With(resource, (HRBCClientPrivate.API.Field.FieldType)((int)(fieldType)), $"{resource}_{fieldType}")
                                   .Searchable(true)
                                   .Build().Content, $"{resource}_{fieldType}");
                }
                request.Append(CreateFieldRequest.Builder().With(resource, HRBCClientPrivate.API.Field.FieldType.OptionCheckbox, $"{resource}_OptionCheckbox")
                               .OptionCount(0).OptionMaster("Option.P_ContructorType").DisplayType(DisplayType.CheckBox).Build().Content, $"{resource}_OptionCheckbox");
            }
            ReferenceTargetFieldCreator = new HrbcFieldCreator((CreateFieldsRequest.IBuilderWithRecord)request, new[] { FieldProperty.Id, FieldProperty.Resource, FieldProperty.Name, FieldProperty.FieldType });
        }
Beispiel #5
0
        private void InitUserFieldTextType()
        {
            // create request
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, FieldType.SingleLineText, "Single Line Text",
                                           builder => builder.Searchable(true).Required(false), $"{resourceId}-{FieldType.SingleLineText}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            IEnumerable <FieldProperty> select = new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            };

            customFields    = new HrbcFieldCreator(fieldRequest, select);
            referenceFields = new HrbcFieldCreator(InitUserFieldReference, select);
        }
Beispiel #6
0
        private void InitFieldCreator()
        {
            //We have to hard-code the id of the master option since there is an issue of HrbcClientPrivate.
            const ulong TempMasterOption = 31;

            var        fieldRequestBuilder = FieldRequest.CreateFields();
            ResourceId resourceId          = ResourceType.ToPrivateEnum();

            foreach (var displayType in Enum.GetValues(typeof(DisplayType)).Cast <DisplayType>())
            {
                fieldRequestBuilder.Append(resourceId, HRBCClientPrivate.API.Field.FieldType.Option, "API automation test field",
                                           builder => builder.Searchable(false).OptionCount((displayType == DisplayType.SearchBox || displayType == DisplayType.RadioButton) ? 1 : 0).DisplayType((displayType == DisplayType.SearchBoxMultiSelection ? DisplayType.SearchBox : displayType)).OptionMaster(TempMasterOption).Required(false), $"{resourceId}-{displayType}");
            }

            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
Beispiel #7
0
        private void InitFieldCreator()
        {
            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")
                                           .Required(false).Web(false).Highlight(false).Height(50).DisplayType(DisplayType.SearchBoxMultiSelection), $"{resourceId}-{Field1}");
                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")
                                           .Required(false).Web(false).Highlight(false).Height(50).DisplayType(DisplayType.SearchBoxMultiSelection), $"{resourceId}-{Field2}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
Beispiel #8
0
        public static HrbcFieldCreator InitUserFieldReference(ResourceId resource, ResourceId refRes)
        {
            // create request for reference field
            var fieldReferenceRequestBuilder = FieldRequest.CreateFields();
            var fieldBuilder = FieldRequest.CreateFields();

            fieldBuilder.Append(refRes, FieldType.Mail, $"{FieldType.Mail}",
                                content => content.Searchable(true).Copy(false).Required(false), $"{refRes}-{FieldType.Mail.ToString()}");

            IEnumerable <FieldProperty> select = new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            };
            var customFields = new HrbcFieldCreator(((CreateFieldsRequest.IBuilderWithRecord)fieldBuilder).Build().Content, select);

            var id = UuidUtil.GetId(customFields.Data[$"{refRes}-{FieldType.Mail.ToString()}"].Guid);

            fieldReferenceRequestBuilder.Append((ResourceId)(int)resource, FieldType.Reference, "Reference Field",
                                                builder => builder.LinkedField(id.ToString()).Searchable(true).Required(false), $"referenceField");

            return(new HrbcFieldCreator(((CreateFieldsRequest.IBuilderWithRecord)fieldReferenceRequestBuilder).Build().Content, select));
        }
        private void PrepareFields()
        {
            var request = FieldRequest.CreateFields();

            var fieldList = new List <HrbcFieldCreator.FieldSpec>();

            foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None }))
            {
                foreach (var fieldType in FieldTypeToTest.Except(new[] { TestCoreFramework.Enums.FieldType.File }))
                {
                    request.Append(CreateFieldRequest.Builder().With(resource, (HRBCClientPrivate.API.Field.FieldType)((int)(fieldType)), $"{resource}_{fieldType}").Build().Content, $"{resource}_{fieldType}");
                }
                foreach (var imageType in ImageFileTypes)
                {
                    request.Append(CreateFieldRequest.Builder().With(resource, HRBCClientPrivate.API.Field.FieldType.File, $"{resource}_File_{imageType}")
                                   .DisplayType(DisplayType.SearchBoxMultiSelection)
                                   .Height(50)
                                   .MimeType("image/gif,image/jpeg,image/png,image/bmp,image/x-ms-bmp").Build().Content, $"{resource}_File_{imageType}");
                }
            }
            FieldCreator = new HrbcFieldCreator((CreateFieldsRequest.IBuilderWithRecord)request, new[] { FieldProperty.Id, FieldProperty.Resource, FieldProperty.Name, FieldProperty.FieldType });
        }
        private void InitFieldCreator()
        {
            var requestBuilder = FieldRequest.CreateFields();

            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Client]), $"{Enums.ResourceType.Client}");
            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Recruiter]), $"{Enums.ResourceType.Recruiter}");
            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Job]), $"{Enums.ResourceType.Job}");
            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Candidate]), $"{Enums.ResourceType.Candidate}");
            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Resume]), $"{Enums.ResourceType.Resume}");
            requestBuilder.Append((ResourceId)(int)Enums.ResourceType.Sales, HRBCClientPrivate.API.Field.FieldType.Reference, "API automation test field",
                                  builder => builder.LinkedField(defaultField[Enums.ResourceType.Process]), $"{Enums.ResourceType.Process}");

            var referenceFieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)requestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(referenceFieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
        private void InitFieldCreator()
        {
            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.Age, "API automation test field",
                                           builder => builder.Required(true), $"{resourceId}-{Required}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Age, "API automation test field",
                                           builder => builder.Required(false), $"{resourceId}-{NoRequired}");

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

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

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

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Age, "API automation test field",
                                           builder => builder.Copy(true), $"{resourceId}-{Copy}");
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Age, "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
            });
        }
        private void InitFieldCreator()
        {
            //We have to hard-code the id of the master option since there is an issue of HrbcClientPrivate.
            const ulong TempMasterOption = 161;

            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.OptionCheckbox, "API automation test field",
                                           builder => builder.Searchable(false).OptionCount(0).OptionMaster(TempMasterOption).Required(false).DisplayType(DisplayType.CheckBox), $"{resourceId}-{FieldType.OptionCheckbox}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.OptionDropdown, "API automation test field",
                                           builder => builder.Searchable(false).OptionCount(0).OptionMaster(TempMasterOption).Required(false).DisplayType(DisplayType.DropDown), $"{resourceId}-{FieldType.OptionDropdown}");

                fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.OptionRadioButton, "API automation test field",
                                           builder => builder.Searchable(false).OptionCount(1).OptionMaster(TempMasterOption).Required(false).DisplayType(DisplayType.RadioButton), $"{resourceId}-{FieldType.OptionRadioButton}");
            }
            var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;

            customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> {
                FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
            });
        }
Beispiel #13
0
        private static BulkUpdateProperties GetBulkUpdateContent(ResourceId resource, List <ulong> ids, int index, string testDateTime, TestCoreFramework.Enums.FieldType type, HrbcFieldCreator fieldCreator)
        {
            Func <ResourceId, KeyValuePair <object, FieldPropertyCollection>, KeyValuePair <string, FieldContent> > userFieldDataGenerator = (resourceId, x)
                                                                                                                                             => new KeyValuePair <string, FieldContent>(x.Value.Name, new FieldContent {
                Content = testDateTime
            });
            var fields = fieldCreator.Data.Where(x => x.Value.Field.Resource == resource)
                         .Select(x => userFieldDataGenerator(resource, x))
                         .Concat(new List <KeyValuePair <string, FieldContent> > {
                new KeyValuePair <string, FieldContent>(SearchConstants.FieldTypeToApplicationFieldNameMap[type], new FieldContent {
                    Content = testDateTime
                })
            })
                         .Concat(SearchConstants.SystemFieldsValues[resource].Where(x => type == x.Key).Select(field => new KeyValuePair <string, FieldContent>(field.Value, new FieldContent {
                Content = testDateTime
            })))
                         .ToDictionary(pair => pair.Key, pair => pair.Value);
            var bulkUpdate = new BulkUpdateProperties();

            bulkUpdate.Create                       = new Create();
            bulkUpdate.Create.Resource              = resource.ToString();
            bulkUpdate.Create.Tag                   = resource.ToString();
            bulkUpdate.Create.Records               = new Records();
            bulkUpdate.Create.Records.Ids           = ids;
            bulkUpdate.Create.Records.PhpSearch     = string.Empty;
            bulkUpdate.Create.Fields                = fields;
            bulkUpdate.Create.CheckPhasePermissions = true;
            return(bulkUpdate);
        }
        private static CreateRecordRequest.IContentBuilder PrepareUserFieldContent(CreateRecordRequest.IContentBuilder content, Enums.ResourceType resourceType, HrbcFieldCreator customField, int referenceId, string fieldValue)
        {
            var result = ResourceHelper.PrepapeInitialRecordContent(content, resourceType.ToPrivateEnum(),
                                                                    clientId: recordsToRef.Data[$"{ResourceId.Client}{referenceId}"].Id,
                                                                    recruiterId: recordsToRef.Data[$"{ResourceId.Recruiter}{referenceId}"].Id,
                                                                    jobId: recordsToRef.Data[$"{ResourceId.Job}{referenceId}"].Id,
                                                                    candidateId: recordsToRef.Data[$"{ResourceId.Person}{referenceId}"].Id,
                                                                    resumeId: recordsToRef.Data[$"{ResourceId.Resume}{referenceId}"].Id);

            var fieldName = customField.Data[$"{resourceType}-{FieldType.Telephone}-0"].Name;

            result.Append(fieldName, fieldValue);

            return(result);
        }
        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 #16
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"));
        }
        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 #18
0
        public static PrivateData <object> PrepareReferenceField(List <ResourceId> resources, HrbcFieldCreator fieldsCreator, int indexReferenceField, Dictionary <ResourceId, Dictionary <ResourceId, Guid> > guidsForUpdate)
        {
            return(new PrivateData <object>(
                       (session, test) =>
            {
                return Task.Run <object>(() =>
                {
                    var handler = new FieldManager();
                    var guids = new Dictionary <ResourceId, Guid>();

                    foreach (var resource in resources)
                    {
                        foreach (var refResource in Defines.ReferenceResource[resource])
                        {
                            var response = handler.CreateField(resource, new Dictionary <string, object>
                            {
                                [Properties.PropertyName.SType.GetEnumStringValue()] = Defines.FieldTypeApi,
                                [Properties.PropertyName.Label.GetEnumStringValue()] = CommonMapperValue.LabelMapperValue[Properties.Label.Min],
                                [Properties.PropertyName.Field.GetEnumStringValue()] = UuidUtil.GetId(fieldsCreator.Data[$"{refResource}-{FieldType.Mail.ToString()}-{indexReferenceField}"].Guid)
                            });

                            PrAssume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
                            guids[refResource] = response.Result.Id;
                        }
                        guidsForUpdate[resource] = guids;
                    }
                    return new object();
                });
            },
                       (session, test, res) => Task.Run(() =>
            {
                //Clearn up
                CommonHelpers.DeleteField(guidsForUpdate.Values.SelectMany(x => x.Select(y => y.Value)));
            })));
        }
        /// <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 #20
0
        public static PrivateData <int> GetBulkUpdate(int numbRecords, int numRecordsEachCase, HrbcRecordCreator recordsCreator, string fieldValue, TestCoreFramework.Enums.FieldType type, HrbcFieldCreator fieldCreator)
        {
            return(new PrivateData <int>(
                       (session, test) =>
            {
                return Task.Run(() =>
                {
                    foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None }))
                    {
                        var bulkManager = new BulkUpdateManager();

                        for (var i = 0; i < numbRecords - numRecordsEachCase; i++)
                        {
                            var recordId = recordsCreator.Data[$"{resource}{i}"].Id;
                            var response = bulkManager.BulkUpdate <BulkUpdateResponse>(GetBulkUpdateContent(resource, new List <ulong> {
                                recordId
                            }, i, fieldValue, type, fieldCreator), System.Net.Http.HttpMethod.Post);
                            PrAssume.That(response, PrIs.SuccessfulResponse());

                            if (GetBulkUpdateQueueStatus(response.Result.Id.ToString()))
                            {
                                continue;
                            }
                        }
                    }
                    return 0;
                });
            },
                       (session, test, res) => Task.Run(() =>
            {
            })));
        }
        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 TestWriteOtherEncodingUserField() : base()
        {
            var fieldRequestBuilder = FieldRequest.CreateFields();

            foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>())
            {
                fieldRequestBuilder.Append((ResourceId)(int)resourceId, FieldType.MultiLinesText, "API automation test field",
                                           builder => builder.TextLength(TextLength), $"{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"));
        }
 public TestInvalidSingleSearchTextType() : base()
 {
     customFields = SearchHelper.InitUserFieldTextType();
 }
Beispiel #24
0
 public TestInvalidSpecialCharactersTextType() : base()
 {
     customFields = SearchHelper.InitUserFieldTextType();
 }
 public static IEnumerable <string> GetFieldData(HrbcFieldCreator fieldsCreator, ResourceId resourceId, FieldType fieldType, int index, bool isGuid = true)
 {
     return(fieldsCreator.Data.Where(x => ((FieldDescriptor)x.Key).Resource == resourceId && ((FieldDescriptor)x.Key).Type == fieldType &&
                                     ((FieldDescriptor)x.Key).Index == index).Select(x => isGuid ? x.Value.Guid.ToString() : x.Value.Name));
 }
        public static PrivateData <Dictionary <TestCoreFramework.Enums.ResourceType, Guid> > PreapreFieldLayouts(HrbcFieldCreator fieldsCreator)
        {
            return(new PrivateData <Dictionary <TestCoreFramework.Enums.ResourceType, Guid> >(
                       (session, test) =>
            {
                return Task.Run(() =>
                {
                    var result = new Dictionary <TestCoreFramework.Enums.ResourceType, Guid>();
                    foreach (TestCoreFramework.Enums.ResourceType resource in Enum.GetValues(typeof(TestCoreFramework.Enums.ResourceType)))
                    {
                        var fieldManager = new FieldManager();

                        var createSectionResponse = fieldManager.CreateSection(resource);
                        PrAssume.That(createSectionResponse, PrIs.SuccessfulResponse <Dictionary <string, Guid> >());

                        var unusedFieldsSectionResponnse = fieldManager.GetUnusedFieldsSectionDetails(resource);
                        PrAssume.That(unusedFieldsSectionResponnse, PrIs.SuccessfulResponse <GetLayoutResponse>());

                        UnusedSections[resource] = unusedFieldsSectionResponnse.Result;

                        var appFieldsToActivate = fieldManager.GetFieldGuid(AppFields.Select(x => x.Value).ToArray(), new[] { resource }).Result;
                        var userFieldsToActivate = fieldsCreator.Data.Where(x => ((FieldDescriptor)x.Key).Resource == resource.ToPrivateApiResource()).Select(x => x.Value.Guid);
                        var sysFieldsToActivate = fieldManager.GetFieldGuid(MoveMissingFieldToLayout[resource.ToPrivateApiResource()], new[] { resource }).Result;
                        var guids = fieldsCreator.Data.Where(x => ((FieldDescriptor)x.Key).Resource == resource.ToPrivateApiResource()).Select(x => x.Value.Guid)
                                    .Concat(appFieldsToActivate.Result.Select(x => x.Id))
                                    .Concat(userFieldsToActivate);
                        if (MoveMissingFieldToLayout[resource.ToPrivateApiResource()].Count() != 0)
                        {
                            guids = guids.Concat(sysFieldsToActivate.Result.Select(x => x.Id));
                        }

                        var setLayoutResponse = fieldManager.MakeFieldsActive(resource, guids.ToArray(),
                                                                              UnusedSections[resource].Values.First().Value, createSectionResponse.Result.Single().Value);

                        PrAssume.That(setLayoutResponse, PrIs.SuccessfulResponse());

                        result[resource] = createSectionResponse.Result["id"];
                    }
                    return result;
                });
            },
                       (session, test, ids) =>
            {
                return Task.Run(() =>
                {
                    foreach (var id in ids)
                    {
                        var setFieldsReqeust = new SetLayoutRequest
                        {
                            Values = new Dictionary <Guid, LayoutItem>
                            {
                                [UnusedSections[id.Key].Values.First().Key] = new LayoutItem
                                {
                                    Id = UnusedSections[id.Key].Values.First().Key,
                                    Cells = UnusedSections[id.Key].Values.First().Value.Cells
                                },
                                [id.Value] = new LayoutItem
                                {
                                    Id = id.Value,
                                    Cells = new List <CellItem>()
                                }
                            }
                        };

                        var handler = new DefaultManager();
                        var response = handler.Send(setFieldsReqeust);

                        PrAssume.That(response, PrIs.SuccessfulResponse());

                        response = handler.Send(FieldManager.FieldLayoutApiRelativeUrl, new Dictionary <string, string> {
                            ["id[0]"] = id.Value.ToString()
                        }, TestCoreFramework.Enums.HttpMethod.DELETE);
                        PrAssume.That(response, PrIs.SuccessfulResponse());
                    }
                });
            }
                       ));
        }
        private static CreateRecordRequest.IContentBuilder PrepareContent(CreateRecordRequest.IContentBuilder content, Enums.ResourceType resourceType, HrbcFieldCreator customField, string[] applicationField)
        {
            var result = ResourceHelper.PrepapeInitialRecordContent(content, resourceType.ToPrivateEnum(),
                                                                    clientId: recordsToRef.Data[$"{ResourceId.Client}{0}"].Id,
                                                                    recruiterId: recordsToRef.Data[$"{ResourceId.Recruiter}{0}"].Id,
                                                                    jobId: recordsToRef.Data[$"{ResourceId.Job}{0}"].Id,
                                                                    candidateId: recordsToRef.Data[$"{ResourceId.Person}{0}"].Id,
                                                                    resumeId: recordsToRef.Data[$"{ResourceId.Resume}{0}"].Id);

            foreach (var item in applicationField)
            {
                result.Append(item, GetValidValueAppField(item));
            }
            foreach (var fieldType in KeywordHelper.KeywordTextField)
            {
                var fieldName = customField.Data[$"{resourceType}-{fieldType}"].Name;
                result.Append(fieldName, GetValidValueUserField(fieldType, fieldName));
            }
            return(result);
        }
Beispiel #28
0
        public TestWriteNullEmptyUserField() : 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")
                                           .Required(false).Web(false).Highlight(false).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 #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 TestInvalidMultipleSearchNumberType() : base()
 {
     customFields = SearchHelper.InitUserFieldNumberType(2);
 }