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; }); }