public static async Task UploadAsync(UploadArguments arguments)
{
var process = Enumeration.FromDisplayName <Process>(arguments.ProcessName);
if (process.Type != Process.ProcessType.Upload)
{
throw new ArgumentException($"Process {arguments.ProcessName} can not be uploaded.", nameof(process));
}
var apiEndpoint = new Uri(arguments.ApiEndpoint);
await using (var fileStream = File.OpenRead(arguments.Filename))
using (var client = GetClient(apiEndpoint, arguments.Token))
using (var streamContent = new StreamContent(fileStream))
using (var content = new MultipartFormDataContent())
{
content.Add(streamContent, "file", arguments.Filename);
var response = await client.PostAsync(process.Name, content, CancellationToken.None).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
Console.WriteLine($"Upload of file {arguments.Filename} to API endpoint {new Uri(apiEndpoint, arguments.ProcessName)}");
}
else
{
await PrintErrorAsync(response, new Uri(apiEndpoint, arguments.ProcessName), process.Type, CancellationToken.None).ConfigureAwait(false);
}
}
}
public void Should_return_enumerated_value_by_display_name()
{
var value = Enumeration.FromDisplayName <TestEnumeration>("Red");
Assert.AreNotSame(TestEnumeration.Blue, value);
Assert.AreSame(TestEnumeration.Red, value);
}
public T GetEnumeration <T>(string columnName) where T : Enumeration, new()
{
var displayName = GetString(columnName);
var value = Enumeration.FromDisplayName <T>(displayName);
return(value);
}
public void TestEqualsWithDynamic()
{
var dyn = Enumeration.FromDisplayName <TestEnum> ("ValueTwo");
Assert.IsTrue(TestEnum.ValueTwo.Equals(dyn));
Assert.AreEqual(TestEnum.ValueTwo, dyn);
}
//[RequiredPermission(ActionType.ShowCustomField)]
public List <CustomFieldDTO> GetAllCustomFields(string entityType)
{
var entityCustomFieldList = customFieldRep.GetAll(Enumeration.FromDisplayName <EntityTypeEnum>(entityType));
return
(entityCustomFieldList.Select(c => customFieldMapper.MapToModel(c))
.ToList());
}
public static string EnumerationDropDownList <T>(this HtmlHelper helper, string listName, bool includeBlankOption,
string selectedName, object htmlOptions)
where T : Enumeration, new()
{
var selectedValue = selectedName == null ? (int?)null : Enumeration.FromDisplayName <T>(selectedName).Value;
return(EnumerationDropDownList <T>(helper, listName, includeBlankOption, selectedValue, htmlOptions));
}
public void When_FromDisplayName_is_called_then_the_correct_Truck_should_be_returned()
{
// Act
CarType result = Enumeration.FromDisplayName <CarType>("Truck");
// Assert
result.Should().Be(CarType.Truck, because: "the car type truck has the display name 'Truck'");
}
protected override T ReadInternal(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.String)
{
return(null);
}
return(Enumeration.FromDisplayName <T>((string)reader.Value));
}
public async Task <Unit> Handle(UpdateCategoryCommand cmd)
{
var category = await _ctx.Categories.FindAsync(cmd.CategoryId);
category.Update(cmd.Name, Enumeration.FromDisplayName <Color>(cmd.Color), cmd.Icon);
return(Unit.Value);
}
public async Task OnExecute()
{
var category = Enumeration.FromDisplayName <ProductCategory>(_config.GetValue <string>("Category"));
var count = _config.GetValue <int>("Count");
_data.GetDatabaseContext().Database.Migrate();
await _mediator.Send(new ScrapeAndTweetCommand { Category = category, Count = count });
}
public async Task <IEnumerable <OrderVm> > GetAllOrdersByServiceTypeAsync(string type)
{
var servType = Enumeration.FromDisplayName <ServiceType>(type.Replace(" ", ""));
var result = await _orderRepository.GetAllByStatus(servType);
var vm = AutoMapper.Mapper.Map <List <Order>, List <OrderVm> >(result.OrderByDescending(x => x.DateTimeStamp).ToList());
return(vm);
}
public ConstructionSet(string identifier)
{
var separator = new [] { "::" };
var parts = identifier.Split(separator, StringSplitOptions.None);
Vintage = Enumeration.FromDisplayName <Vintages>(parts[0]);
ClimateZone = Enumeration.FromDisplayName <ClimateZones>(parts[1]);
ConstructionType = Enumeration.FromDisplayName <ConstructionTypes>(parts[2]);
}
private static Enumeration GetEnumeration(Type enumerationType, string value)
{
int enumValue;
bool isEnumerationValueBinding = int.TryParse(value, out enumValue);
return(isEnumerationValueBinding
? Enumeration.FromValue(enumerationType, enumValue)
: Enumeration.FromDisplayName(enumerationType, value));
}
public Order Convert(OrderVm source, Order destination, ResolutionContext context)
{
var servType = Enumeration.FromDisplayName <ServiceType>(source.ServiceType.Replace(" ", ""));
//var pizzas = src.Pizzas.Select(x => Mapper.Map<PizzaVm, Pizza>(x)).ToList();
var pizzas = source.Pizzas.Select(Mapper.Map <PizzaVm, Pizza>).ToList();
var result = new Order(servType, pizzas, source.Name);
return(result);
}
public Order Convert(ResolutionContext context)
{
var src = (OrderVm)context.SourceValue;
var servType = Enumeration.FromDisplayName <ServiceType>(src.ServiceType.Replace(" ", ""));
var pizzas = src.Pizzas.Select(x => Mapper.Map <PizzaVm, Pizza>(x)).ToList();
var result = new Order(servType, pizzas, src.Name);
return(result);
}
public ProgramType(string identifier)
{
var separator = new[] { "::" };
var parts = identifier.Split(separator, StringSplitOptions.None);
Vintage = Enumeration.FromDisplayName <Vintages>(parts[0]);
BuildingProgram = Enumeration.FromDisplayName <BuildingPrograms>(parts[1]);
RoomProgram = Enumeration.FromDisplayName <RoomPrograms>(parts[2]);
}
//[RequiredPermission(ActionType.ShowCustomField)]
public List <AbstractCustomFieldDescriptionDTO> GetAllCustomFieldsDescription(string entityType)
{
//var fs = new ListFetchStrategy<CustomFieldType>(Enums.FetchInUnitOfWorkOption.NoTracking);
var entityCustomFieldList = customFieldRep.GetAll(Enumeration.FromDisplayName <EntityTypeEnum>(entityType));
return
(entityCustomFieldList.Select(c => abstractCustomFieldDescriptionDTOMapper.MapToModel(c))
.ToList());
}
public void criar_enumeration_a_partir_do_nome()
{
var all = Enumeration.GetAll <State>();
foreach (var item in all)
{
var state = Enumeration.FromDisplayName <State>(item.Name);
Assert.Equal(state.Id, item.Id);
}
}
private bool TryGetApplicationOperation(string input, out ApplicationOperationType operation)
{
operation = Enumeration.FromDisplayName <ApplicationOperationType>(input);
if (operation == null)
{
return(false);
}
return(true);
}
public void ValidDisplayNameShouldReturnCorrectEnumerationValue()
{
ExampleEnumeration shouldBeA = Enumeration.FromDisplayName <ExampleEnumeration>("A");
ExampleEnumeration shouldBeB = Enumeration.FromDisplayName <ExampleEnumeration>("B");
ExampleEnumeration shouldBeC = Enumeration.FromDisplayName <ExampleEnumeration>("C");
Assert.Equal(ExampleEnumeration.A, shouldBeA);
Assert.Equal(ExampleEnumeration.B, shouldBeB);
Assert.Equal(ExampleEnumeration.C, shouldBeC);
}
public void IsValidEnumerationFromDisplayName()
{
var all = Enumeration.GetAll <State>();
foreach (var item in all)
{
var state = Enumeration.FromDisplayName <State>(item.Name);
Assert.Equal(state.Id, item.Id);
}
}
public Domain.Aggregates.Lobby Map(Data.Model.Lobby data)
{
var rounds = data.Rounds != null?JsonConvert.DeserializeObject <List <Data.Model.Round> >(data.Rounds) : new List <Data.Model.Round>();
var players = data.Players != null?JsonConvert.DeserializeObject <List <Data.Model.Player> >(data.Players) : new List <Data.Model.Player>();
var domain = new Domain.Aggregates.Lobby
{
GameState = Enumeration.FromDisplayName <State>(data.GameState),
RoundNumber = data.RoundNumber,
DateCreated = data.DateCreated,
Code = data.Code,
};
domain.Players = players.Select(player =>
new Domain.Entities.Player
{
Name = player.PlayerName,
Identifier = player.ConnectionId,
Score = player.Score,
Id = 0,
Connected = player.Connected
}).ToList();
domain.Deck = new Deck(data.Deck.Select(id =>
{
var owner = players.FirstOrDefault(player => player.Hand.Contains(id));
var card = new Card(id)
{
Discarded = data.Discard.Contains(id),
Owner = owner != null ? domain.GetPlayerByName(owner.PlayerName) : null,
RoundSubmitted = rounds.FirstOrDefault(round => round.Cards.Contains(id) || id == round.StoryTellerCard)?.Counter ?? 0
};
return(card);
}).ToList());
domain.Rounds = rounds.Select(round =>
{
var newRound = new Domain.ValueObjects.Round(round.Counter, domain.GetPlayerByName(round.StoryTeller))
{
Counter = round.Counter,
Story = round.Story,
StoryTellerCard = domain.GetCard(round.StoryTellerCard),
Votes = round.Votes.Select(vote => new Domain.ValueObjects.Vote(
domain.GetPlayerByName(vote.Player),
domain.Deck.FindCard(vote.Card)
)).ToList()
};
return(newRound);
}).ToList();
return(domain);
}
public static Condition SetCondition(string condition)
{
try
{
return(Enumeration.FromDisplayName <Condition>(condition));
}
catch
{
return(Enums.Vehicles.Condition.Excellent);
}
}
public static StateOfVehicle SetStateOfVehicle(string stateOfVehicle)
{
try
{
return(Enumeration.FromDisplayName <StateOfVehicle>(stateOfVehicle));
}
catch
{
return(EnumDisplayNameParser.StateOfVehicleFromName(stateOfVehicle));
}
}
public static Transmission SetTransmission(string transmission)
{
try
{
return(Enumeration.FromDisplayName <Transmission>(transmission));
}
catch
{
return(EnumDisplayNameParser.TransmissionFromName(transmission));
}
}
public static FuelType SetFuelType(string fuelType)
{
try
{
return(Enumeration.FromDisplayName <FuelType>(fuelType));
}
catch
{
return(EnumDisplayNameParser.FuelTypeFromName(fuelType));
}
}
public static Drivetrain SetDrivetrain(string driveTrain)
{
try
{
return(Enumeration.FromDisplayName <Drivetrain>(driveTrain));
}
catch
{
return(Drivetrain.Other);
}
}
public static BodyStyle SetBodyStyle(string bodyStyle)
{
try
{
return(Enumeration.FromDisplayName <BodyStyle>(bodyStyle));
}
catch
{
return(EnumDisplayNameParser.BodyStyleFromName(bodyStyle));
}
}
public void MapFromTable(ref CustomerSessionModel domainModel, CustomerSessionTableRecord databaseModel)
{
if (domainModel == null)
{
domainModel = new CustomerSessionModel();
}
domainModel.Id = databaseModel.Id;
domainModel.VendingMachineId = databaseModel.VendingMachineId;
domainModel.Status = Enumeration.FromDisplayName <CustomerSessionStatusEnum>(databaseModel.Status);
domainModel.CustomerBalance = Balance.Empty.Decode(databaseModel.BalanceText);
}
public static MileageUnit SetMileageUnit(string mileageUnit)
{
try
{
return(Enumeration.FromDisplayName <MileageUnit>(mileageUnit));
}
catch
{
return(MileageUnit.MI);
}
}
