public async Task <QueryResult <Client> > GetAllAsync(ClientQuery queryObj)
{
var result = new QueryResult <Client>();
var query = _context.Clients
.Include(client => client.SourcedFrom)
.Include(client => client.Projects).ThenInclude(p => p.AssignedUser)
.Include(client => client.Projects).ThenInclude(p => p.Status)
.Include(client => client.Projects).ThenInclude(p => p.Product)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(queryObj.SearchTerm))
{
query = query.Where(client => client.Name.Contains(queryObj.SearchTerm) ||
client.Email.Contains(queryObj.SearchTerm) ||
client.ClientCode.Contains(queryObj.SearchTerm) ||
client.PhoneNumber.Contains(queryObj.SearchTerm));
}
var columnsMap = new Dictionary <string, Expression <Func <Client, object> > >
{
["email"] = p => p.Email,
["name"] = p => p.Name,
["sourcedFrom"] = p => p.SourcedFrom.Name,
["clientCode"] = p => p.ClientCode
};
query = query.ApplyOrdering(queryObj, columnsMap);
result.TotalItems = await query.CountAsync();
query = query.ApplyPaging(queryObj);
result.Items = await query.ToListAsync();
return(result);
}
/// <inheritdoc cref="AbstractCommand.Execute" />
public override ServerResponse Execute
(
ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
ServerResponse result = base.Execute(query);
result.GetReturnCode();
// ReSharper disable AssignNullToNotNullAttribute
// ReSharper disable PossibleNullReferenceException
// ReSharper disable ForCanBeConvertedToForeach
for (int i = 0; i < References.Count; i++)
{
ProtocolText.ParseResponseForWriteRecords
(
result,
References[i].Record
);
References[i].Mfn = References[i].Record.Mfn;
}
// ReSharper restore ForCanBeConvertedToForeach
// ReSharper restore PossibleNullReferenceException
// ReSharper restore AssignNullToNotNullAttribute
return(result);
}
public void ReadPostingsCommand_ExecuteRequest_1()
{
int returnCode = 0;
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
ReadPostingsCommand command = new ReadPostingsCommand(connection)
{
Database = "IBIS",
ListOfTerms = new []
{
"FIRST",
"SECOND",
"THIRD"
}
};
ResponseBuilder builder = new ResponseBuilder()
.StandardHeader(CommandCode.ReadPostings, 123, 456)
.NewLine()
.Append(returnCode)
.NewLine();
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
ServerResponse response = command.Execute(query);
Assert.AreEqual(returnCode, response.ReturnCode);
}
public async Task <IActionResult> PutClientQuery(int id, ClientQuery query)
{
if (id != query.QueryId)
{
return(BadRequest());
}
_context.Entry(query).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientQueryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.ReadRecord;
string database = Database ?? Connection.Database;
if (string.IsNullOrEmpty(database))
{
throw new IrbisNetworkException("database not specified");
}
result.Arguments.Add(database);
result.Arguments.Add(Mfn);
if (VersionNumber != 0)
{
result.Arguments.Add(VersionNumber);
}
else
{
result.Arguments.Add(Lock);
}
if (!string.IsNullOrEmpty(Format))
{
result.Arguments.Add(Format);
}
return(result);
}
public virtual ServerResponse Execute
(
[NotNull] ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
Log.Trace("AbstractCommand::Execute");
byte[] request = query.EncodePacket();
byte[] answer = Connection.Socket
.ExecuteRequest(request);
Log.Trace
(
"AbstractCommand::Execute: answer.Length="
+ answer.Length
);
ServerResponse result = new ServerResponse
(
Connection,
answer,
request,
RelaxResponse
);
return(result);
}
public void ReadFileCommand_ExecuteRequest_1()
{
int returnCode = 0;
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
ReadFileCommand command = new ReadFileCommand(connection)
{
Files =
{
new FileSpecification(IrbisPath.MasterFile, "IBIS", "file.txt")
}
};
ResponseBuilder builder = new ResponseBuilder()
.StandardHeader(CommandCode.ReadDocument, 123, 456)
.NewLine()
.Append(returnCode)
.NewLine();
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
ServerResponse response = command.Execute(query);
Assert.IsNotNull(response);
}
//
// GET
//
public IEnumerable <Client> Get(ClientQuery query)
{
return((from c in _context.Client
where c.Key == query.ClientKey || query.ClientKey == null
select c)
.ToArray());
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.UnlockRecords;
string database = Database ?? Connection.Database;
if (string.IsNullOrEmpty(database))
{
Log.Error
(
"UnlockRecordsCommand::CreateQuery: "
+ "database not specified"
);
throw new IrbisException("database not specified");
}
result.AddAnsi(database);
if (Records.Count == 0)
{
Log.Error
(
"UnlockRecordsCommand::CreateQuery: "
+ "record list is empty"
);
throw new IrbisException("record list is empty");
}
result.Arguments.AddRange(Records.Cast <object>());
return(result);
}
public void TestClientQuery_Clear()
{
ClientQuery query = _GetClientQuery();
query.Clear();
Assert.AreEqual(0, query.Arguments.Count);
}
private void query_QueryResponse(object sender, QueryResponseEventArgs e)
{
this.Output += "e.ResponseEventType = " + e.ResponseEventType + " | ";
if (e.ResponseEventType.Equals(QueryResponseEventType.Error))
{
Error(e.Errors[0]);
}
else
{
//AccountQuery query = sender as AccountQuery;
ClientQuery query = sender as ClientQuery;
// Request more data
if (query != null)
{
this.Output += "Query.State = " + query.State + " | ";
if (query.State == QueryState.MoreImagesAvailable)
{
query.RequestMoreData();
}
}
// Consume data
BindingList <Client> list = this.query.GetList();
foreach (Client client in list)
{
this.Output += client.ClientCode;
}
OnPropertyChanged(new PropertyChangedEventArgs("Output"));
}
}
public void TestCreateQuery()
{
QueryClassRelation relation = new QueryClassRelation().SetId(3);
ClientQuery query =
ClientQuery.For <QueryClass>()
.Add((QueryClass q) => q.Name == "test name")
.Add((QueryClass q) => q.Type == QueryClassType.First)
.Add((QueryClass q) => q.RelatedTo == relation);
Assert.AreEqual("Atlanta.Application.Services.ServiceBase.Test.QueryClass", query.ForClass);
Assert.AreEqual(3, query.Expressions.Count);
Assert.AreEqual("Name", query.Expressions[0].Property);
Assert.AreEqual(ExpressionType.Equal, query.Expressions[0].Operator);
Assert.AreEqual("test name", query.Expressions[0].Operand);
Assert.AreEqual("Type", query.Expressions[1].Property);
Assert.AreEqual(ExpressionType.Equal, query.Expressions[1].Operator);
Assert.AreEqual(QueryClassType.First, query.Expressions[1].Operand);
Assert.AreEqual("RelatedTo", query.Expressions[2].Property);
Assert.AreEqual(ExpressionType.Equal, query.Expressions[2].Operator);
Assert.AreEqual(3, ((QueryClassRelation)query.Expressions[2].Operand).Id);
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = ReverseOrder
? CommandCode.ReadTermsReverse
: CommandCode.ReadTerms;
string database = Database
?? Connection.Database;
if (string.IsNullOrEmpty(database))
{
Log.Error
(
"ReadTermsCommand::CreateQuery: "
+ "database not specified"
);
throw new IrbisException("database not specified");
}
string preparedFormat = IrbisFormat.PrepareFormat
(
Format
);
result
.AddAnsi(database)
.AddUtf8(StartTerm)
.Add(NumberOfTerms)
.AddAnsi(preparedFormat);
return(result);
}
/// <summary>
/// Execute the command.
/// </summary>
public override ServerResponse Execute
(
ClientQuery clientQuery
)
{
Sure.NotNull(clientQuery, nameof(clientQuery));
ServerResponse result = base.Execute(clientQuery);
result.GetReturnCode();
if (result.ReturnCode == 0)
{
int expected = result.RequireInt32();
FoundCount = expected;
List <FoundItem> foundList = FoundItem
.ParseServerResponse(result, expected)
.ThrowIfNull("Found");
Found = foundList;
_FetchRemaining(result, expected);
if (!_subCommand &&
FirstRecord == 1 &&
NumberOfRecords == 0)
{
Debug.Assert
(
foundList.Count == expected,
"Found.Count != expected in total"
);
}
}
return(result);
}
public void SearchCommand_ExecuteRequest_2()
{
int returnCode = 0;
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
SearchCommand command = new SearchCommand(connection)
{
Database = "IBIS",
SearchExpression = "A=AUTHOR$",
MinMfn = 0,
MaxMfn = 0,
SequentialSpecification = "p(v300)",
FormatSpecification = "(v300/)"
};
ResponseBuilder builder = new ResponseBuilder()
.StandardHeader(CommandCode.Search, 123, 456)
.NewLine()
.Append(returnCode)
.NewLine()
.Append(0)
.NewLine();
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
ServerResponse response = command.Execute(query);
Assert.AreEqual(returnCode, response.ReturnCode);
Assert.IsNotNull(command.Found);
Assert.AreEqual(0, command.Found.Count);
}
private ClientQuery readQuery(JToken jToken, IClientMessageCache messageTypes, JsonSerializer serializer)
{
var messageName = jToken["type"].Value <string>();
var chain = messageTypes.FindChain(messageName);
string correlationId = null;
var correlationIdToken = jToken["correlationId"];
if (correlationIdToken != null)
{
correlationId = correlationIdToken.Value <string>();
}
var query = new ClientQuery {
type = messageName, correlationId = correlationId
};
if (chain.InputType() != null)
{
var reader = new JTokenReader(jToken["query"]);
query.query = serializer.Deserialize(reader, chain.InputType());
}
return(query);
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.DatabaseStat;
// "2" STAT
// "IBIS" database
// "v200^a,10,100,1" field
// "T=A$" search
// "0" min
// "0" max
// "" sequential
// "" mfn list
string items = string.Join
(
IrbisText.IrbisDelimiter,
Definition.Items
.Select(item => item.ToString())
.ToArray()
);
result
.Add(Definition.DatabaseName)
.Add(items)
.AddUtf8(Definition.SearchQuery)
.Add(Definition.MinMfn)
.Add(Definition.MaxMfn)
.AddUtf8(Definition.SequentialQuery)
.Add(string.Empty) // instead of MFN list
;
return(result);
}
/// <inheritdoc cref="AbstractCommand.Execute"/>
public override ServerResponse Execute
(
ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
ServerResponse result = base.Execute(query);
if (!string.IsNullOrEmpty(FormatSpecification))
{
result.GetReturnCode();
}
int count = 1;
if (VirtualRecord == null)
{
count = MfnList.Count;
}
FormatResult = GetFormatResult
(
result,
count
);
return(result);
}
public void ConnectCommand_ExecuteRequest_2()
{
int returnCode = 0;
string configuration = "Some=Text";
Mock <IIrbisConnection> mock = GetConnectionMock();
mock.SetupGet(c => c.Connected).Returns(true);
IIrbisConnection connection = mock.Object;
ConnectCommand command = new ConnectCommand(connection)
{
Username = "******",
Password = "******"
};
ResponseBuilder builder = new ResponseBuilder()
.AppendAnsi(CommandCode.RegisterClient).NewLine()
.AppendAnsi("12345678").NewLine()
.AppendAnsi("1").NewLine()
.AppendAnsi("123").NewLine()
.AppendAnsi("64.2014").NewLine()
.NewLine()
.NewLine()
.NewLine()
.NewLine()
.NewLine()
.Append(returnCode).NewLine()
.AppendAnsi("30").NewLine()
.AppendAnsi(configuration);
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
command.Execute(query);
}
/// <inheritdoc cref="AbstractCommand.CreateQuery"/>
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.ListFiles;
if (Specifications.Count == 0)
{
Log.Error
(
"ListFilesCommand::CreateQuery: "
+ "specification list is empty"
);
throw new IrbisException("specification list is empty");
}
foreach (FileSpecification specification in Specifications)
{
specification.Verify(true);
result.Add(specification);
}
return(result);
}
/// <inheritdoc cref="AbstractCommand.Execute"/>
public override ServerResponse Execute
(
ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
ServerResponse result = base.Execute(query);
byte[] buffer = result.RawAnswer;
Encoding encoding = IrbisEncoding.Ansi;
byte[] preamble = encoding.GetBytes(Preamble);
int offset = _FindPreamble(buffer, preamble);
if (offset < 0)
{
Log.Error
(
"ReadBinaryFileCommand::Execute: "
+ "no binary data received"
);
throw new IrbisNetworkException
(
"No binary data received"
);
}
offset += preamble.Length;
Content = result.RawAnswer.GetSpan(offset);
return(result);
}
/// <inheritdoc cref="AbstractCommand.Execute" />
public override ServerResponse Execute
(
ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
string database = Record.ThrowIfNull("Record").Database
?? Connection.Database;
ServerResponse result = base.Execute(query);
MaxMfn = result.GetReturnCode();
MarcRecord record = Record.ThrowIfNull("Record");
record.Database = database;
record.HostName = Connection.Host;
if (!DontParseResponse)
{
ProtocolText.ParseResponseForWriteRecord
(
result,
record
);
}
return(result);
}
public IActionResult ManageClients(string message = null)
{
SetupViewBag();
ClientViewModel[] clients;
if (User.IsInRole("SuperAdmin"))
{
clients = ClientQuery
.AsEnumerable()
.Select(c =>
{
var model = _mapper.Map <ClientViewModel>(c);
model.Editable = true;
return(model);
})
.ToArray();
}
else
{
clients = ClientQuery
.AsEnumerable()
.Select(c => _mapper.Map <ClientViewModel>(c))
.ToArray();
}
return(View(clients));
}
public IEnumerable <ClientLanguage> GetClientLanguageArray(ClientQuery query)
{
return((from cl in _context.ClientLanguage
where cl.ClientKey == query.ClientKey || query.ClientKey == null
select cl)
.ToArray());
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.RestartServer;
return(result);
}
/// <inheritdoc cref="AbstractCommand.CreateQuery" />
public override ClientQuery CreateQuery()
{
ClientQuery result = base.CreateQuery();
result.CommandCode = CommandCode.GetProcessList;
return(result);
}
/// <summary>
/// Get a list of Media for the system Library
/// </summary>
public ServiceResult<IList<Media>> GetMediaList(User user,
ClientQuery mediaCriteria)
{
return ServiceResult<IList<Media>>
.Return(DomainRegistry.Library.GetMediaList(mediaCriteria.ToDetachedCriteria())
.GraphList()
.Add(m => m.Library)
.CopyList());
}
/// <summary>
/// Get a list of Media for the system Library
/// </summary>
public ServiceResult <IList <Media> > GetMediaList(User user,
ClientQuery mediaCriteria)
{
return(ServiceResult <IList <Media> >
.Return(DomainRegistry.Library.GetMediaList(mediaCriteria.ToDetachedCriteria())
.GraphList()
.Add(m => m.Library)
.CopyList()));
}
/// <inheritdoc cref="AbstractCommand.Execute" />
public override ServerResponse Execute
(
ClientQuery query
)
{
Sure.NotNull(query, nameof(query));
Log.Trace("ConnectCommand::Execute");
if (Connection.Connected)
{
Log.Error
(
"ConnectCommand::Execute: "
+ "already connected"
);
throw new IrbisException("Already connected");
}
ServerResponse result;
while (true)
{
result = base.Execute(query);
Log.Trace
(
"ConnectCommand::Execute: returnCode="
+ result.ReturnCode
);
// CLIENT_ALREADY_EXISTS
if (result.ReturnCode == -3337)
{
IrbisConnection connection = Connection as IrbisConnection;
int newId = ReferenceEquals(connection, null)
? Connection.ClientID + 1
: connection.GenerateClientID();
query.ClientID = newId;
}
else
{
break;
}
}
if (result.ReturnCode == 0)
{
ConfirmationInterval = result.RequireInt32();
Configuration = result.RemainingAnsiText();
}
ServerVersion = result.ServerVersion;
return(result);
}
public IActionResult Update([FromQuery] ClientQuery query, [FromBody] Client client)
{
if (client == null || client.Key != query.ClientKey)
{
return(BadRequest());
}
return(_clientRepo.Update(query, client));
}
public void SearchCommand_CreateQuery_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
SearchCommand command = new SearchCommand(connection);
ClientQuery query = command.CreateQuery();
Assert.IsNotNull(query);
}
public void Test_GetSingleCustomersOverWCF()
{
CustomerQueryServiceReference.CustomerQueryServiceClient query = new CustomerQueryServiceReference.CustomerQueryServiceClient();
Common.Util.AssignContextId(query.InnerChannel);
ClientQuery<Customer> c = new ClientQuery<Customer>();
IQueryable q = c.Where(c1 => c1.CustomerId == "ALFKI");
XElement xe = q.SerializeQuery();
Customer results = query.Where(xe);
Assert.That(results, Is.Not.Null);
}
