public async Task GetPhaseEntry()
{
// create request
var builer = GetPhaseEntryRequest.Builder();
builer.AddResource((int)ResourceId.Client)
.AddParentId(10063)
//.AppendField("Phase.P_Id")
.AppendField("Phase.P_Phase")
//.AppendField("Phase.P_PhaseDate")
//.AppendField("Phase.P_PhaseMemo")
//.AppendField("Phase.P_UpdateDate")
//.AppendField("Phase.P_UpdateId")
.AppendField("Phase.flag");
var request = builer.Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var entries = await session.CallAsync(builer.Build());
Assert.That(entries, Is.Not.Null, "Flow is null!");
Assert.That(entries.PhaseEntryList, Is.Not.Null, "Flow is null!");
Assert.That(entries.PhaseEntryList.First().Id, Is.Not.Null, "Flow is null!");
}
}
public async Task TestCreateUser()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
var request = CreateUserRequest.Builder()
.AddName("Nam Tran")
.AddStartDate(DateTime.Now)
.AddDeptId(1001)
.AddLanguage("en_us")
.AddMail("*****@*****.**")
.AddSender(new List <string> {
"*****@*****.**", "*****@*****.**"
})
.AddAdminNewsMailFlg(true)
.AddAdministrator(true)
.Build();
var result = await session.CallAsync(request);
Assert.That(result, Is.Not.Null, "Response data is null!");
Assert.That(result.Id, Is.GreaterThan(0), "Wrong field id value!");
}
}
public async Task CreatesFieldWithAlias()
{
// create request
string expectedAlias = "TESTAUTOALIASUNIQUE";
var fieldRequestBuilder = FieldRequest.CreateFields();
fieldRequestBuilder.Append(ResourceId.Job, FieldType.Number, "Test Auto API",
builder => builder.Required(false).Name(expectedAlias), $"{(FieldType.Number).ToString()}");
var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var fields = await session.CallAsync(FieldRequest.CreateFields(fieldRequest));
Assert.That(fields.FieldSuccess, Is.Not.Null.And.Not.Empty, "FieldSuccess is null or empty!");
Assert.That(fields.FieldSuccess.ContainsKey($"{(FieldType.Number).ToString()}"), "The response data doesn't contain any guid!");
//Get Field
var mapping = fields.FieldSuccess.ToDictionary(entry => entry.Value, entry => entry.Key);
var resultField = (await session.CallAsync(FieldRequest.GetFields().Select(new List <FieldProperty> {
FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource
}).WhereGuid(fields.FieldSuccess.Values)))
.ToDictionary(fieldEntry => mapping[fieldEntry.Value.Guid], fieldEntry => fieldEntry.Value);
Assert.That(resultField.ContainsKey($"{(FieldType.Number).ToString()}"), "The Response does not contain any data.");
data = resultField;
string createdAlias = resultField[$"{(FieldType.Number).ToString()}"].Field.ToAlias();
Assert.That(createdAlias, Is.EqualTo($"Job.U_{expectedAlias}"), $"Created Alias {createdAlias} is different with expected");
}
}
public async Task TestCreateEquivalentUser()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
Random rand = new Random();
string email = "nam.tran" + rand.Next() + "@porters.jp";
var request = CreateUserRequest.Builder()
.AddName("Nam Tran")
.AddTel("")
.AddMail(email)
.AddUsername("namtran12")
.AddMobile("")
.AddMobileMail("")
.AddApprovalFlg(false)
.AddTimeZone("Asia/Saigon")
.AddEndDate(DateTime.Now)
.AddNewsMailFlg(true)
.AddStartDate(DateTime.Now)
.AddDeptId(1001)
.AddLanguage("en_us")
.AddAdminNewsMailFlg(true)
.AddAdministrator(true);
var result = await session.CallAsync(request);
Assert.That(result.Id, Is.GreaterThan(0), "Create equivalent user failed!");
}
}
/// <summary>
/// One time call to create Private Client
///
/// </summary>
/// <param name="accessHelper"></param>
public void CreatePrivateClient(string serverURL = null)
{
if (_privateClient == null)
{
try
{
ILoggerFactory l = null;
//Log.Info("Creating PrivateClient on " + serverURL);
LoggerFactory factory = new LoggerFactory();
factory.AddDebug(Microsoft.Extensions.Logging.LogLevel.Trace);
PrivateServerSettings settings = new PrivateServerSettings {
ServerUrl = new Uri(serverURL ?? TestConfig.GetValueFromConfig("PrivateServer")), LoggerFactory = factory
};
_privateClient = PrivateClient.CreateClient(settings);
}
catch (Exception e)
{
//Log.Error(e);
}
}
else
{
//Log.Info("PrivateClient already created");
}
}
public async Task ServerTest()
{
var req = FieldRequest.CreateFields();
req = req.Append(CreateFieldRequest.Builder().With(ResourceId.Activity, FieldType.Number, "test").Build().Content);
var built = ((CreateFieldsRequest.IBuilderWithRecord)req).Build();
IPrivateClient client = PrivateClient.CreateClient(new PrivateServerSettings {
ServerUrl = new Uri("http://namtest3-web.dynamic.ps.porters.local"), LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
});
using (var session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password")))
{
var fields = await session.CallAsync(built);
Assume.That(fields.FieldFailed, Has.Count.EqualTo(0));
Assume.That(fields.FieldSuccess, Has.Count.GreaterThan(0));
var mapping = fields.FieldSuccess.ToDictionary(entry => entry.Value, entry => entry.Key);
var res = await session.CallAsync(FieldRequest.GetFields().Select(FieldProperty.Name).WhereGuid(fields.FieldSuccess.Values));
var conv = res
.ToDictionary(fieldEntry => mapping[(Guid)fieldEntry.Value[FieldProperty.Id]], fieldEntry => fieldEntry.Value);
Assert.That(res, Has.Count.GreaterThan(0));
}
}
public void TestCreateFileUpload()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
var cookie = PrivateConnectionHooks.CookieExtractor(out Func <string, string> func);
string token = func.Invoke("YII_CSRF_TOKEN");
var str = "Client ID,Client Name,Date Updated,Updated by";
var createFileUploadRequest = CreateFileUploadRequest.Builder()
.FrmIf(new HRBCClientPrivate.API.File.JsonFile.FrmIf {
Size = "86", Name = "ImportTestCSVFile.csv", ContentType = "application/vnd.ms-excel", Content = StringToBase64String(str)
})
.CsrfToken(token);
Task <CreateFileUploadResponse> task = session.CallAsync(createFileUploadRequest.Build());
TestContext.Out.WriteLine("Take the second cup of coffee in meantime!");
CreateFileUploadResponse fieldData = task.Result;
Assert.That(fieldData, Is.Not.Null, "Response data is null!");
Assert.AreEqual(fieldData.FieldId, "Test Tester", "Wrong field name value!");
}
}
public async Task CreatePhaseFlow()
{
// create request
var builer = CreatePhaseFlowRequest.Builder();
//builer.AppendFlow(500, new List<ulong> { 500, 513, 514, 515, 406, 407, 405, 404 });
builer.AppendFlow("Option.P_ClientPhase", new List <string> {
"Option.P_ClientContact", "Option.P_ClientNegotiation", "Option.P_ClientLost", "Option.P_ClientSuccessForSale"
});
var request = builer.Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var response = await session.CallAsync(builer.Build());
Assert.That(response, Is.Not.Null, "response is null or empty!");
Assert.That(response.ResultCode, Is.EqualTo(204), "Not Match success code!");
}
}
public async Task CreatesFieldWithAlias()
{
// create request
var builer = GetFieldLayoutRequest.Builder();
builer.AppendId("00000000-0000-07d1-4009-00000000058d");
var request = builer.Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var fields = await session.CallAsync(builer.Build());
Assert.That(fields, Is.Not.Null, "fields is null or empty!");
Assert.That(fields.Data, Is.Not.Null, "Fields is null or empty!");
Assert.That(fields.Data.Values, Is.Not.Null.And.Not.Empty, "Fields.Values is null or empty!");
Assert.That(fields.Data.Values.Single(), Is.Not.Null, "Values.Single is null or empty!");
Assert.That(fields.Data.Values.Single().Cells, Is.Not.Null.And.Not.Empty, "Cells is null or empty!");
Assert.That(fields.Data.Values.Single().Cells.First(), Is.Not.Null, "First Cell is null or empty!");
Assert.That(fields.Data.Values.Single().Cells.First().Content, Is.Not.Null, "First cell content is null or empty!");
Assert.That(fields.Data.Values.Single().Cells.First().Content.First().Key, Is.Not.Null.And.Not.Empty.And.EqualTo("field"), "Content key is null or empty or field!");
Assert.That(fields.Data.Values.Single().Cells.First().Content.First().Value.ToString(), Is.EqualTo("00000000-0000-2c7e-4000-00050000058d"), "content value is null or empty!");
}
}
public static ClientMocker ToRequestMocker(this HrbcVersion version)
{
var mock = new Mock <HttpClientHandler>();
return(new ClientMocker(mock, PrivateClient.CreateClient(new PrivateServerSettings {
HttpClientHandlerFactory = () => mock.Object, Version = version, AutoDetectVersion = false, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
})));
}
public void SetUp()
{
string serverUrl = "http://namtest2-web.dynamic.ps.porters.local";
PrivateServerSettings settings = new PrivateServerSettings();
settings.ServerUrl = new Uri(serverUrl);
client = PrivateClient.CreateClient(settings);
session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password"));
Assume.That(session.Authenticate(), Is.True, "Cannot login to the server!");
}
protected override IPrivateClient GetClient(string id)
{
if (init == null)
{
PrivateServerSettings settings = new PrivateServerSettings {
ServerUrl = new Uri(TestConfig.GetValueFromConfig("PrivateServer")), LoggerFactory = LogHelper.GetDefaultLoggerFactory()
};
init = Tuple.Create(PrivateClient.CreateClient(settings), id);
}
return(init.Item1);
}
public void TestPrivateAuthenticationSuccess()
{
IPrivateClient client = PrivateClient.CreateClient(new PrivateServerSettings {
ServerUrl = new Uri("http://namtest3-web.dynamic.ps.porters.local")
});
using (var session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password")))
{
var result = session.Call(MetaDataRequest.LastUpdated(1));
Assert.That(result.LastUpdateDate, Is.GreaterThan(0));
}
}
public async Task UpdateSingleField()
{
IPrivateClient 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 req = await session.CallAsync(FieldRequest.UpdateField().Field("Client.P_Name".ToField()).Label("Woof"));
Assert.That(req);
}
}
public async Task DeleteCreatedField()
{
if (data != null)
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
await session.CallAsync(FieldRequest.DeleteFields(data.Values.Select(col => col.Guid)));
}
}
}
protected virtual IPrivateClient GetClient(string id)
{
if (init == null)
{
LoggerFactory factory = new LoggerFactory();
factory.AddDebug(LogLevel.Trace);
PrivateServerSettings settings = new PrivateServerSettings {
ServerUrl = new Uri(TestConfig.GetValueFromConfig("PrivateServer")), LoggerFactory = factory
};
init = Tuple.Create <IPrivateClient, string>(PrivateClient.CreateClient(settings), id);
}
return(init.Item1);
}
public async Task DeleteSingleRecordI()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = new Uri("http://deletetest-web.dynamic.ps.porters.local"), LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password")))
{
var request = DeleteRecordRequest.Builder().Append(ResourceId.Process, 10001, 10002);
var response = await session.CallAsync(request);
Assert.That(response.DeletedRecords, Has.Count.EqualTo(1));
Assert.That(response.DeletedRecords.Keys, Does.Contain(ResourceId.Process));
Assert.That(response.DeletedRecords[ResourceId.Process], Has.Count.EqualTo(2));
Assert.That(response.DeletedRecords[ResourceId.Process], Does.Contain(10001));
Assert.That(response.DeletedRecords[ResourceId.Process], Does.Contain(10002));
}
}
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));
}
}
public void TestGetUser()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
var getRequest = GetUserRequest.Builder()
.Id(1)
.AddField(UserField.Name)
.AddField(UserField.Address)
.AddField(UserField.AdminNewsMailFlg);
Task <GetUserResponse> task = session.CallAsync(getRequest.Build());
TestContext.Out.WriteLine("Take the second cup of coffee in meantime!");
GetUserResponse fieldData = task.Result;
Assert.That(fieldData, Is.Not.Null, "Response data is null!");
Assert.AreEqual(fieldData.Name, "Test Tester", "Wrong field name value!");
}
}
public async Task TestUpdateUser()
{
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
var request = UpdateUserRequest.Builder()
.AddId(1)
.AddName("Nam Tran")
.AddStartDate(DateTime.Now)
.AddDeptId(1001)
.AddLanguage("en_us")
.AddMail("*****@*****.**");
var result = await session.CallAsync(request);
Assert.That(result, Is.EqualTo(204), "Wrong response code!");
}
}
public async Task RetrievesData()
{
PrivateClient client = PrivateClient.CreateClient(new PrivateServerSettings {
ServerUrl = new Uri("http://arwyntest-web.dynamic.ps.porters.local")
});
using (PrivateSession session = client.CreateSession(PrivateAuthentication.WithCredentials("TestCompany", "*****@*****.**", "password")))
{
var request = ResourceRequest.GetRecords(ResourceId.Process)
.WithFields(FieldCollection.Builder()
.Append("Process.P_PhaseMemo".ToField())
.Build())
.WithRecords(10003);
var result = await session.CallAsync(request);
Assert.That(result.RecordData.Count, Is.EqualTo(1));
Assert.That(result.RecordData.First().Version, Is.EqualTo(1));
Assert.That(result.RecordData.First().Count, Is.EqualTo(2));
Assert.That(result.RecordData.First().RecordId, Is.EqualTo(10003));
Assert.That(result.RecordData.First()["Process.P_PhaseMemo".ToField()], Is.EqualTo("サンプル選考プロセスメモ"));
}
}
public async Task DeletePhaseFlow()
{
// create request
var builer = DeletePhaseFlowRequest.Builder();
builer.AddFlowId(500).IsRecursive(true);
var request = builer.Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var response = await session.CallAsync(builer.Build());
Assert.That(response, Is.Not.Null, "Response is null or empty!");
Assert.That(response.Data.Count, Is.GreaterThan(0), "Response Count is empty!");
Assert.That(response.Data.Values.Where(v => v.Depth == "1").Single().FlowItems, Is.Null, "Flow is not null!");
}
}
public async Task GetPhaseFlow()
{
// create request
var builer = GetPhaseFlowRequest.Builder();
builer.AddResourceId((int)ResourceId.Client);
var request = builer.Build().Content;
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var flows = await session.CallAsync(builer.Build());
Assert.That(flows, Is.Not.Null, "Flow is null!");
Assert.That(flows.Data.Count, Is.GreaterThan(0), "Flows Count is empty!");
Assert.That(flows.Data.Values, Is.Not.Null.And.Not.Empty, "Flows.Values is null or empty!");
}
}
public async Task SearchOption()
{
// create request
var builer = OptionSearchRequest.Builder();
builer.AddName("Option.P_ClientContact").AddLevel(-1);
//Get session
using (var client = PrivateClient.CreateClient(new PrivateServerSettings()
{
ServerUrl = server, LoggerFactory = TestLoggerFactoryAttribute.CurrentLoggerFactory
}))
using (var session = client.CreateSession(auth))
{
//Send Request
var searchContent = await session.CallAsync(builer.Build());
Assert.That(searchContent, Is.Not.Null, "search content is null!");
Assert.That(searchContent.Options, Is.Not.Null, "Options is null!");
Assert.That(searchContent.Options.First().Alias, Is.Not.Null, "Alias is null!");
Assert.That(searchContent.Options.First().ParentId, Is.Not.Null.Or.Not.EqualTo(0), "Parent is null or 0!");
//Assert.That(searchContent.Options.First().Name, Is.Not.Null, "Name is null!");
}
}
