public void identity_should_be_divided_into_domain_and_userName()
{
var actual = CollectionBuilder.CreateForCredentials(new MyPrincipal("gauffin.com\\jgauffin"));
actual.Properties["UserName"].Should().Be("jgauffin");
actual.Properties["DomainName"].Should().Be("gauffin.com");
}
public async Task <CustomerAddress> Address(string id)
{
REPO.Customer _cust = (from c in context.Customers
where c.CustomerNumber == id
select c).FirstOrDefault();
IEnumerable <REPO.Address> _addresses = _cust.Addresses.Where(a => a.AddressTypeCode == "01" || a.AddressTypeCode == "02");
CustomerAddress _custsaddr = new CustomerAddress();
_custsaddr.CustomerNumber = _cust.CustomerNumber;
foreach (REPO.Address a in _addresses)
{
this.TransformAddress(a, _custsaddr);
}
ServicePartitionClient <HttpCommunicationClient> partitionClient
= new ServicePartitionClient <HttpCommunicationClient>(communicationFactory, serviceUri, new ServicePartitionKey());
await partitionClient.InvokeWithRetryAsync(
async (client) =>
{
IEnumerable <Code> _request = CollectionBuilder.BuildAddressCodesRequest(_custsaddr);
HttpResponseMessage response = await client.HttpClient.PostAsJsonAsync(new Uri(client.Url, "Services/Codes"), _request);
IEnumerable <Code> _codes = await response.Content.ReadAsAsync <IEnumerable <Code> >();
_custsaddr = this.AddEnterpriseCodesToAddress(_custsaddr, _codes);
});
return(_custsaddr);
}
public void should_add_both_to_the_collection_if_specified()
{
var actual = CollectionBuilder.Feedback("*****@*****.**", "Hello world");
actual.Properties["EmailAddress"].Should().Be("*****@*****.**");
actual.Properties["Description"].Should().Be("Hello world");
}
public void should_also_support_just_userName_in_the_Identity_constructor()
{
var actual = CollectionBuilder.CreateForCredentials(new MyIdentity("jgauffin"));
actual.Properties["UserName"].Should().Be("jgauffin");
actual.Properties.ContainsKey("Domain").Should().BeFalse();
}
public override TCollection Read(JsonReader reader, Type objectType)
{
var builder = new CollectionBuilder <TCollection, TItem>();
reader.ReadStartArray();
if (PrimitiveFormatter <TItem> .CanRead)
{
while (reader.Peek() != JsonToken.EndArray)
{
builder.Add(reader.ReadValue <TItem>());
}
}
else
{
var contract = reader.Settings.ResolveContract(typeof(TItem));
while (reader.Peek() != JsonToken.EndArray)
{
builder.Add(reader.ReadValueInternal <TItem>(contract));
}
}
reader.ReadEndArray();
return(builder.ToCollection());
}
public void SetFixedCollection(Action <World, CollectionBuilder <CommandProcessSystemBase> > build)
{
var cb = new CollectionBuilder <CommandProcessSystemBase>();
build(World, cb);
SystemProcessors = cb.Build();
}
/// <summary>
/// Récupération d'une liste d'objets d'un certain type correspondant à un critère donnée.
/// </summary>
/// <param name="collection">Collection à charger.</param>
/// <param name="commandName">Nom de la commande.</param>
/// <param name="queryParameter">Paramètres de tri et de limite (vide par défaut).</param>
/// <param name="criteria">Map de critères auquelle la recherche doit correpondre.</param>
/// <returns>Collection.</returns>
private ICollection <T> InternalLoadAll(ICollection <T> collection, string commandName, QueryParameter queryParameter, FilterCriteria criteria)
{
int maxRows = BrokerManager.NoLimit;
if (queryParameter != null)
{
// Définition du tri à partir de la requete.
queryParameter.RemapSortColumn(typeof(T));
// Definition du maxRows
maxRows = GetMaxRowCount(queryParameter.MaxRows);
}
IReadCommand cmd = this.GetCommand(commandName, _definition.ContractName, criteria, maxRows, queryParameter);
ICollection <T> coll = CollectionBuilder <T> .ParseCommand(collection, cmd);
long collCount = coll.Count;
if (queryParameter != null && (queryParameter.Offset > 0 || queryParameter.Limit > 0))
{
collCount = QueryContext.InlineCount.Value;
}
if (maxRows > BrokerManager.NoLimit && collCount > maxRows)
{
throw new BrokerException("Store return too many rows.");
}
return(coll);
}
public void userName_domainName_constructor_should_bE_able_To_Assign_values_propertly()
{
var actual = CollectionBuilder.CreateForCredentials("gauffin.com", "jgauffin");
actual.Properties["UserName"].Should().Be("jgauffin");
actual.Properties["DomainName"].Should().Be("gauffin.com");
}
private async Task <Customer> EnrichCustomer(REPO.Customer cust)
{
Customer _final = this.TransformCustomer(cust);
_final.HomePhone = cust.Phones.Where(p => p.PhoneTypeID == "01").FirstOrDefault() != null?cust.Phones.Where(p => p.PhoneTypeID == "01").FirstOrDefault().PhoneNumber : null;
_final.MobilePhone = cust.Phones.Where(p => p.PhoneTypeID == "04").FirstOrDefault() != null?cust.Phones.Where(p => p.PhoneTypeID == "04").FirstOrDefault().PhoneNumber : null;
string _accessToken = (User as ClaimsPrincipal).FindFirst("token").Value;
ServicePartitionClient <HttpCommunicationClient> partitionClient
= new ServicePartitionClient <HttpCommunicationClient>(communicationFactory, serviceUri, new ServicePartitionKey());
await partitionClient.InvokeWithRetryAsync(
async (client) =>
{
IEnumerable <Code> _request = CollectionBuilder.BuildCustomerCodesRequest(_final);
client.HttpClient.SetBearerToken(_accessToken);
HttpResponseMessage response = await client.HttpClient.PostAsJsonAsync(new Uri(client.Url, "Services/Codes"), _request);
IEnumerable <Code> _codes = await response.Content.ReadAsAsync <IEnumerable <Code> >();
_final = this.AddEnterpriseCodesToCustomer(_final, _codes);
});
return(_final);
}
public FormUrlEncodedContent AsFormUrlEncodedContent()
{
var collection = new CollectionBuilder()
.AddRequired("refund[carrier]".ToKvp(Carrier))
.AddRequired("refund[tracking_codes]".ToKvp(string.Join(",", TrackingCodes)));
return(collection.AsFormUrlEncodedContent());
}
public void BuildEmptyCollections()
{
var collections = new List <string>();
var result = CollectionBuilder.CreateCollectionsTable(collections);
Assert.AreEqual(result, "xdmp.defaultCollections()");
}
private void ConfigureCoderr(IApplicationBuilder app)
{
var url = new Uri("https://report.coderr.io/");
Err.Configuration.Credentials(url,
"2b3002d3ab3e4a57ad45cff2210221ab",
"f381a5c9797f49bd8a3238b892d02806");
Err.Configuration.ThrowExceptions = false;
app.CatchMiddlewareExceptions();
if (!HostConfig.Instance.IsConfigured)
{
return;
}
CoderrConfigSection config;
try
{
var dbStore = new DatabaseStore(() => OpenConnection(CoderrClaims.SystemPrincipal));
config = dbStore.Load <CoderrConfigSection>();
if (config == null)
{
return;
}
}
catch (SqlException)
{
// We have not yet configured coderr.
return;
}
// partitions allow us to see the number of affected installations
Err.Configuration.AddPartition(x => x.AddPartition("InstallationId", config.InstallationId));
Err.Configuration.FilterCollection.Add(new BundleSlowReportPosts());
if (string.IsNullOrWhiteSpace(config.ContactEmail))
{
return;
}
// Allows us to notify you once the error is corrected.
Err.Configuration.ReportPreProcessor = report =>
{
if (string.IsNullOrWhiteSpace(config.ContactEmail))
{
return;
}
var collection = CollectionBuilder.Feedback(config.ContactEmail, null);
var collections = new List <ContextCollectionDTO>(report.ContextCollections.Length + 1);
collections.AddRange(report.ContextCollections);
collections.Add(collection);
};
}
public void CreateForCredentials_should_support_domain_names()
{
var identity = new GenericIdentity("myjob\\someone");
var actual = CollectionBuilder.CreateForCredentials(identity);
actual.Properties["UserName"].Should().Be("someone");
actual.Properties["DomainName"].Should().Be("myjob");
}
public void CreateForCredentials_should_work_without_domain_names()
{
var identity = new GenericIdentity("someone");
var actual = CollectionBuilder.CreateForCredentials(identity);
actual.Properties["UserName"].Should().Be("someone");
actual.Properties.Should().NotContainKey("DomainName");
}
public void AddOne_Will_Return_The_Builder_It_Just_Added_To_Builders()
{
var parentBuilder = new BuilderForTesting <ExampleClass>();
var t = new CollectionBuilder <ExampleChildClass, ExampleChildClassBuilder>(parentBuilder);
var res = t.AddOne();
t.Builders.Should().OnlyContain(x => x == res);
}
public void AddOne_Will_Add_Item_Builder_To_Builders()
{
var parentBuilder = new BuilderForTesting <ExampleClass>();
var t = new CollectionBuilder <ExampleChildClass, ExampleChildClassBuilder>(parentBuilder);
t.AddOne();
t.Builders.Count.Should().Be(1, "only one builder should be added");
t.Builders.Should().ContainItemsAssignableTo <ExampleChildClassBuilder>();
}
public void AddMany_Will_Reuse_Same_Item_Builder()
{
var parentBuilder = new BuilderForTesting <ExampleClass>();
var t = new CollectionBuilder <ExampleChildClass, ExampleChildClassBuilder>(parentBuilder);
t.AddMany(3);
t.Builders.Count.Should().Be(3);
t.Builders.Should().OnlyContain(x => x == t.Builders[0]);
}
/// <summary>
/// This method sets up the collection properties on the context instance
/// </summary>
public void SetupCollections()
{
// Check the database
if (Database != null)
{
// Set the context into the builder
CollectionBuilder = new CollectionBuilder <TContext>(this as TContext, Database);
// Configure the collections
OnConfiguringCollections(CollectionBuilder);
}
}
/// <summary>
/// This method selects a database from the MongoDB server
/// </summary>
/// <param name="database"></param>
/// <returns></returns>
protected DbContext <TContext> Use(string database)
{
// Load the database into the instance
Database = Client.GetDatabase(database);
// Set the database into the collection builder
CollectionBuilder.WithDatabase(Database);
// Setup the collections in the instance
SetupCollections();
// We're done, return the instance
return(this);
}
public void BuildOneElementCollections()
{
var collections = new List <string>()
{
"one"
};
var result = CollectionBuilder.CreateCollectionsTable(collections);
Assert.AreEqual(result, "[\"one\"]");
}
public WfActivityDefinition FindActivityDefinitionByPosition(WfWorkflowDefinition wfWorkflowDefinition, int position)
{
var cmd = GetSqlServerCommand("FindActivityDefinitionByPosition.sql");
cmd.Parameters.AddWithValue(WfActivityDefinition.Cols.WFWD_ID, wfWorkflowDefinition.WfwdId);
cmd.Parameters.AddWithValue(WfActivityDefinition.Cols.LEVEL, position);
WfActivityDefinition activity = CollectionBuilder <WfActivityDefinition> .ParseCommandForSingleObject(cmd, true);
return(activity);
}
public void AddMany_With_Instances_Will_Add_Item_Builders_With_These_Instances_To_Builders()
{
var parentBuilder = new BuilderForTesting <ExampleClass>();
var t = new CollectionBuilder <ExampleChildClass, ExampleChildClassBuilder>(parentBuilder);
var c = new[] { new ExampleChildClass(), new ExampleChildClass(), new ExampleChildClass() };
t.AddMany(c);
t.Builders.Count.Should().Be(3);
t.CreateAll().Should().Contain(c);
}
public void BuildSimpleCollections()
{
var collections = new List <string>()
{
"one", "two", "three"
};
var result = CollectionBuilder.CreateCollectionsTable(collections);
Assert.AreEqual(result, "[\"one\",\"two\",\"three\"]");
}
public void AddOne_With_Instance_Will_Add_Item_Builder_With_That_Instance_To_Builders()
{
var parentBuilder = new BuilderForTesting <ExampleClass>();
var t = new CollectionBuilder <ExampleChildClass, ExampleChildClassBuilder>(parentBuilder);
var c = new ExampleChildClass();
t.AddOne(c);
t.Builders.Count.Should().Be(1);
t.CreateAll().Should().OnlyContain(x => x == c);
}
/// <summary>
/// Récupération d'un objet à partir de critère de recherche.
/// </summary>
/// <param name="destination">Bean à charger.</param>
/// <param name="criteria">Le critère de recherche.</param>
/// <param name="returnNullIfZeroRow">Retourne null si la recherche a retournée zero ligne.</param>
/// <returns>Objet.</returns>
public T LoadByCriteria(T destination, FilterCriteria criteria, bool returnNullIfZeroRow = false)
{
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
string commandName = ServiceSelect + "_LIKE_" + _definition.ContractName;
IReadCommand cmd = this.GetCommand(commandName, _definition.ContractName, criteria, BrokerManager.NoLimit, null);
return(CollectionBuilder <T> .ParseCommandForSingleObject(destination, cmd, returnNullIfZeroRow));
}
public IBuilder Append(HrbcField field, FieldCollectionBuilderHandler fieldCollectionHandler)
{
var builder = new CollectionBuilder();
if (content.ContainsKey(field) && content[field] != null)
{
builder.Append(content[field]);
}
fieldCollectionHandler(builder);
content[field] = builder.Count > 0 ? builder.Build() : null;
return(this);
}
public void BuildBasicCollectionTest()
{
var builder = new CollectionBuilder <IItemInstance>();
var collection = (Collection <IItemInstance>)builder
.SetSize(10)
.SetSlotType <LayoutCollectionSlot <IItemInstance> >()
.Build();
Assert.AreEqual(10, collection.slotCount);
Assert.AreEqual(typeof(LayoutCollectionSlot <IItemInstance>), collection.GetSlot(0).GetType());
}
public virtual CC Result()
{
CollectionBuilder <A, CC> curr = this;
var res = Empty();
while (curr.RearOption.GetIfPresent(out A rear))
{
res = res.Prepend(rear);
curr = curr.Init;
}
return(res);
}
/// <summary>
/// This method localizes the collection for an entity by its type
/// </summary>
/// <typeparam name="TDocument"></typeparam>
/// <returns></returns>
public IMongoCollection <TDocument> Collection <TDocument>() where TDocument : CollectionModel, new()
{
// Iterate over the entities
foreach (var entity in CollectionBuilder.ListEntities())
{
if (entity.Type == typeof(TDocument))
{
return(entity.GetCollection() as IMongoCollection <TDocument>);
}
}
// We're done, no collection found
return(null);
}
/// <summary>
/// Gets an event stored on cosmos DB from its document id on the collection returned by calling the collection builder with a null AuditEvent.
/// </summary>
/// <param name="docId">The document id</param>
/// <param name="auditEvent">The AuditEvent to use when calling the builders to get the ConnectionString, Database, Collection and AuthKey.</param>
public T GetEvent <T>(string docId, AuditEvent auditEvent)
{
var client = GetClient(auditEvent);
var collectionUri = GetCollectionUri(auditEvent);
var sql = new SqlQuerySpec($"SELECT * FROM {CollectionBuilder?.Invoke(auditEvent)} c WHERE c.id = @id",
new SqlParameterCollection(new SqlParameter[] { new SqlParameter()
{
Name = "@id", Value = docId.ToString()
} }));
return(client.CreateDocumentQuery(collectionUri, sql)
.AsEnumerable()
.FirstOrDefault());
}
private IEnumerable<People> GetPeople(string requestUrl)
{
CollectionBuilder<People> rest = new CollectionBuilder<People>();
return rest.ToCollection(requestUrl, null);
}
private IEnumerable<Photo> GetPhotos(string requestUrl, PhotoSize size)
{
XmlElement doc = elementProxy.GetResponseElement(requestUrl);
XmlElement photosElement = doc.Element("photos");
CollectionBuilder<Photo> builder = new CollectionBuilder<Photo>("photos");
CollectionBuilder<CommonAttribute> commBuilder =
new CollectionBuilder<CommonAttribute>("photos");
CommonAttribute sharedProperty = commBuilder.ToCollection(doc, null).Single();
return builder.ToCollection(photosElement, photo =>
{
photo.Url = (this as IPhotoRepository).GetSizedPhotoUrl(photo.Id, size) ?? string.Empty;
photo.PhotoSize = size;
photo.SharedProperty = sharedProperty;
});
}
