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 <IActionResult> PutPrivateClient(long id, PrivateClient privateClient)
{
if (id != privateClient.ClientId)
{
return(BadRequest());
}
_context.Entry(privateClient).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PrivateClientExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
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 async Task <ActionResult <PrivateClient> > PostPrivateClient(PrivateClient privateClient)
{
_context.PrivateClients.Add(privateClient);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPrivateClient", new { id = privateClient.ClientId }, privateClient));
}
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 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 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 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 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 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 static void SetClientConnection(PrivateClient client)
{
if (ht == null) { ht = new Hashtable(StringComparer.OrdinalIgnoreCase); }
if (!ht.ContainsKey(client.Endpoint.Address.Uri.ToString()))
{
ht.Add(client.Endpoint.Address.Uri.ToString(), client);
}
}
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!");
}
public void connect(string ip, int port)
{
if (serverThread != null)
{
serverThread.Interrupt();
}
PrivateClient server = new PrivateClient(ip, port, commands);
serverThread = new Thread(new ThreadStart(server.sendCommands));
serverThread.IsBackground = true;
serverThread.Start();
}
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));
}
}
/*connects the client to the flight simulator*/
public void Connect(string ip, int port)
{
//if there is already a thread, make sure to interrupt it
if (serverThread != null) serverThread.Interrupt();
//set up the wrapper to the client and start it
PrivateClient server = new PrivateClient(ip, port, commands);
serverThread = new Thread(new ThreadStart(server.SendCommands))
{
IsBackground = true
};
System.Diagnostics.Debug.WriteLine("Client connection astablished on ip = {0} and port = {1}", ip, port);
serverThread.Start();
}
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 IEnumerable <ClientForTraders> ClientsForTrader(int id, string filter)
{
TraderService.CheckCredentials(id);
Trader trader = TraderService.FindEntity(id);
TraderService.CollectCl(trader);
var ret = new List <ClientForTraders>();
Func <ClientForTraders, bool> test = filter.ToTest <ClientForTraders>();
foreach (CommercialLink cl in trader.CommercialLink)
{
PrivateClient privateClient = ClientService.EntityToDTO(cl.Client);
ClientForTraders clientForTrader = privateClient.CastAs <ClientForTraders>();
clientForTrader.CommercialRelation = ClService.GetClStatus(cl);
if (test(clientForTrader))
{
ret.Add(clientForTrader);
}
}
return(ret);
}
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 void OnConfermaClick(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(View.CreditCard.Text) || string.IsNullOrWhiteSpace(View.Email.Text) || string.IsNullOrWhiteSpace(View.Denomination.Text) || string.IsNullOrWhiteSpace(View.NumberCell.Text) || string.IsNullOrWhiteSpace(View.Street.Text) || string.IsNullOrWhiteSpace(View.NumeroCivico.Text) || string.IsNullOrWhiteSpace(View.CAP.Text) || string.IsNullOrWhiteSpace(View.City.Text) || string.IsNullOrWhiteSpace(View.Province.Text) || string.IsNullOrWhiteSpace(View.Nazione.Text) || string.IsNullOrWhiteSpace(View.ID.Text))
{
MessageBox.Show("Devi inserire tutti i campi", "", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
else
{
if (FGManager.Instance.CostumerRiepilogue.GetAll.Where(s => s.ID == View.ID.Text).ToList().Count == 0)
{
try
{
Address newAddress = new Address(View.Street.Text, View.NumeroCivico.Text, View.City.Text, View.CAP.Text, View.Province.Text, View.Nazione.Text);
if (View.Company.Checked)
{
Company newCompany = new Company(View.Denomination.Text, View.CreditCard.Text, View.NumberCell.Text, View.Email.Text, true, newAddress, View.ID.Text);
FGManager.Instance.CostumerRiepilogue.Add(newCompany);
}
else if (View.PrivateSubject.Checked)
{
PrivateClient newPrivateClient = new PrivateClient(View.Denomination.Text, View.CreditCard.Text, View.NumberCell.Text, View.Email.Text, true, newAddress, View.ID.Text);
FGManager.Instance.CostumerRiepilogue.Add(newPrivateClient);
}
MessageBox.Show("Inserimento cliente avvenuto con successo");
}
catch (Exception)
{
MessageBox.Show("Errore imprevisto nella creazione del cliente");
}
}
else
{
MessageBox.Show("Cliente già esistente", "", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
tornaIndietro();
}
}
protected override void BeginProcessing()
{
try
{
if (CMDBSession != null)
{
ConnectionHelper.SetClientConnection(CMDBSession);
_clientconnection = CMDBSession;
}
else
{
if (string.IsNullOrEmpty(URL))
{
var DefaultCMDBURL = SessionState.PSVariable.Get("DefaultCMDBURL");
if (DefaultCMDBURL == null)
{
ThrowTerminatingError(
new ErrorRecord(
new Exception("No Session Object found! Please initaite first a Session Object!"),
"GenericMessage", ErrorCategory.ObjectNotFound, ""));
}
_uri = DefaultCMDBURL.Value.ToString();
}
var uri = string.Format("{0}/services/soap/Private", _uri);
_clientconnection = ConnectionHelper.GetClientConnection(uri, _credential);
SessionState.PSVariable.Set("DefaultCMDBURL",_uri);
}
}
catch (Exception e)
{
ThrowTerminatingError(new ErrorRecord(e, "GenericMessage", ErrorCategory.InvalidOperation, _uri)
);
}
}
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!");
}
}
private static PrivateClient NewClient(string uri, PSCredential credential)
{
CustomBinding custBinding = new CustomBinding();
MtomMessageEncodingBindingElement elmtom = new MtomMessageEncodingBindingElement();
elmtom.MaxWritePoolSize = 2147483647;
elmtom.MaxBufferSize = 2147483647;
elmtom.MessageVersion = MessageVersion.Soap12;
var ssbe = SecurityBindingElement.CreateUserNameOverTransportBindingElement();
ssbe.AllowInsecureTransport = true;
ssbe.IncludeTimestamp = false;
ssbe.MessageSecurityVersion = MessageSecurityVersion.WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10;
var htt = new HttpTransportBindingElement();
htt.MaxBufferPoolSize = 2147483647;
htt.MaxReceivedMessageSize = 2147483647;
htt.MaxBufferSize = 2147483647;
EndpointAddress n = new EndpointAddress(uri);
custBinding.Elements.Add(ssbe);
custBinding.Elements.Add(elmtom);
custBinding.Elements.Add(htt);
var client = new PrivateClient(custBinding, n);
if (credential != null)
{
if (client.ClientCredentials != null)
{
client.ClientCredentials.UserName.UserName = credential.GetNetworkCredential().UserName;
client.ClientCredentials.UserName.Password = SecureStringToString(credential.Password);
}
}
else
{
if (client.ClientCredentials != null)
{
// client.ClientCredentials.UserName.UserName = "******";
//client.ClientCredentials.UserName.Password = "******";
}
}
return client;
}
