private MetaDataRequestAnswer CreateAnswerForRequest(MetaDataRequest metaDataReq)
{
return(new MetaDataRequestAnswer()
{
DomesticChanges = getDomesticChangesSince(metaDataReq.DomesticChangesSince),
AlienChanges = getAlienChangesSince(metaDataReq.AlienChangesSince)
});
}
public async Task <GetFieldPropertyResponse> Handle(PrivateSession session, GetFieldPropertyRequest request, Func <PrivateConnection> connectionFactory)
{
uint companyId = (await session.CallAsync(MetaDataRequest.GetAccountInfo(HrbcAccountInfoProperty.CompanyId))).CompanyId;
// If constraints are set, we resolve them to ids (which are intersectedd with given ids if present), otherwise we use the given ids.
IEnumerable <Guid> ids = request.Constraints.Count() > 0 ? await Search(session, request, connectionFactory, companyId) : EnforceCompany(companyId, request.Ids);
// now get the field data for ids
return(await GetProperties(session, connectionFactory, request, ids));
}
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 <Guid> Save(Stream input, MetaDataRequest request, string fileName, string contentType, string serviceName)
{
var obj = await _fileStorageHelper.SaveFile(input, serviceName);
await _fileService.AddFile(new FileModel()
{
ContentType = _fileHelper.DetectMimeType(request?.FileName ?? fileName),
FileName = request?.FileName ?? fileName,
Bucket = serviceName,
Created = DateTime.Today,
Id = obj
});
return(obj);
}
public async Task <IActionResult> SaveFile([FromForm] IFormFile file, [FromForm] MetaDataRequest model,
[FromServices] AddFileHandler fh, string serviceName)
{
if (file == null)
{
return(BadRequest());
}
using (var fileStream = new MemoryStream())
{
await file.CopyToAsync(fileStream);
fileStream.Position = 0;
await fh.Save(fileStream, model, file.FileName, file.ContentType, serviceName);
}
return(Ok());
}
public async Task <CreateUserResponse> Handle(PrivateSession session, CreateUserRequest request, Func <PrivateConnection> connectionFactory)
{
var csrfToken = await session.CallAsync(MetaDataRequest.GetCrlfToken("mycompany/agents"));
var createUserRequestEquivalentData = new JsonUser.CreateUserRequestEquivalentData
{
Name = request.Name,
AdminNewsMailFlg = request.AdminNewsMailFlg ? 1 : 0,
ApprovalFlg = request.ApprovalFlg ? 1 : 0,
DeptId = request.DeptId,
EndDate = request.EndDate,
Language = request.Language,
Mail = request.Mail,
Mobile = request.Mobile,
MobileMail = request.MobileMail,
NewsMailFlg = request.NewsMailFlg ? 1 : 0,
StartDate = request.StartDate,
Tel = request.Tel,
TimeZone = request.TimeZone,
Username = request.Username,
Role = request.Administrator ? "admin" : "user"
};
var requestModel = new JsonUser.CreateUserRequestEquivalent
{
User = createUserRequestEquivalentData,
CsrfToken = csrfToken
};
using (var connection = connectionFactory().AppendHook(PrivateConnectionHooks.ForceQuery(USER)).Method(PrivateConnectionMethod.Create))
{
try
{
using (var response = await connection.SendAsync(requestModel))
{
var result = await response.ReadAsync <JsonUser.CreateEquivalentUserResponse>();
return(new CreateUserResponse(result.Id));
}
}
catch (ConnectionResponseException e)
{
//FIXME this will not work correctly because response is not in privateapi format.
throw e.ToRequestException("Could not create a user", requestModel);
}
}
}
public static PrivateClient CreateClient(ServerSettings settings = null)
{
// create copy to protect against external changes
var settingToUse = settings == null ? new PrivateServerSettings() : new PrivateServerSettings
{
ServerUrl = settings.ServerUrl,
Version = settings.Version,
AutoDetectVersion = settings.AutoDetectVersion
};
PrivateClient client = new PrivateClient(settingToUse.ReadOnly());
if (settingToUse.AutoDetectVersion)
{
using (var session = client.CreateSession(PrivateAuthentication.NoCredentials))
{
settingToUse.Version = session.Call(MetaDataRequest.DetectCurrentVersion());
}
}
return(client);
}
public static IPrivateClient CreateClient(IServerSettings settings = null)
{
// create copy to protect against external changes
var settingToUse = settings == null ? new PrivateServerSettings() : new PrivateServerSettings
{
ServerUrl = settings.ServerUrl,
Version = settings.Version,
AutoDetectVersion = settings.AutoDetectVersion,
HttpClientHandlerFactory = settings is PrivateServerSettings.IExtraSettings ? ((PrivateServerSettings.IExtraSettings)settings).HttpClientHandlerFactory : null,
LoggerFactory = settings is PrivateServerSettings.IExtraSettings ? ((PrivateServerSettings.IExtraSettings)settings).LoggerFactory : new LoggerFactory(),
};
PrivateClient client = new PrivateClient(settingToUse.ReadOnly());
if (settingToUse.AutoDetectVersion)
{
using (var session = client.CreateSession(PrivateAuthentication.NoCredentials))
{
settingToUse.Version = session.Call(MetaDataRequest.DetectCurrentVersion());
}
}
return(client);
}
private HrbcVersion GetVersion(PrivateAuthentication auth)
{
var privateApiSession = TestBase.PrivateAuthentication.GetPrivateSession(PrivateAuthentication.NoCredentials);
return(privateApiSession.Call <int, HrbcVersion>(MetaDataRequest.DetectCurrentVersion()));
}
protected override void OnReceiveConsumer(object sender, BasicDeliverEventArgs ea)
{
var metaDataReq = MetaDataRequest.FromBytes(ea.Body);
OnMetaDataRequestReceived?.Invoke(this, new MetaDataRequestReceivedArgs(metaDataReq));
}
public void SendRequest(string receiverService, MetaDataRequest metaDataReq)
{
SendBasicPublish(receiverService, metaDataReq.ToBytes());
}
public MetaDataRequestReceivedArgs(MetaDataRequest metaDataReq)
{
MetaDataReq = metaDataReq;
}
public void SendMetaDataShareRequest(string serviceId, MetaDataRequest metaDataRequest)
{
requestModule.SendRequest(serviceId, metaDataRequest);
}
