private int?LocateDomainId(ServiceLanguageInfo language, Grade entity, int?domainId)
{
if (language.Domains != null && domainId != null)
{
var domain = language.Domains.Where(x => x.DomainId == domainId.Value).SingleOrDefault();
if (domain != null)
{
return(domain.Id);
}
}
return(null);
}
public async Task <OperationResult <IEnumerable <ServiceLanguageInfo> > > AddLanguagesAsync(int serviceId, ProviderAddLanguagesBindingModel model, int userId)
{
var newLanguages = new List <ServiceLanguageInfo>();
foreach (var id in model.Languages)
{
var newLanguage = new ServiceLanguageInfo
{
CreatedDate = DateTime.Now,
Comment = model.Comment,
LanguagePairId = id,
QA = new QA {
Comment = model.qaComment, Grade = 0, Stars = (Stars)model.Stars
},
Rate = new ServiceRate {
Minrate = model.MinRate, MaxRate = model.MaxRate
},
ProductivityMax = model.ProductivityMax,
ProductivityMin = model.ProductivityMin,
ServiceId = serviceId,
NativeSpeaker = model.NativeSpeaker
};
newLanguages.Add(newLanguage);
Repo.AddOrUpdate(newLanguage);
// I used to do it in two passes, but it causes error.
// So I save after each add/update
try
{
await Repo.SaveAsUserAsync(userId);
Repo.BindGrades(newLanguage);
await Repo.SaveAsUserAsync(userId);
}
catch (Exception ex)
{
return(OperationResult <IEnumerable <ServiceLanguageInfo> > .Error(string.Format("{0}{1}.", CANNOT_ADD_LANGUAGES, ex.Message)));
}
}
var newLanguageIds = newLanguages.Select(x => x.Id);
var result = Repo
.Get(x => newLanguageIds.Contains(x.Id))
.Include(x => x.LanguagePair)
.Include(x => x.CreatedBy)
.Include(x => x.ModifiedBy)
.ToList();
return(OperationResult <IEnumerable <ServiceLanguageInfo> > .Ok(result));
}
private static async Task RunPackageVersion(RunOptions options, string outputJson, string outputCsv, string outputTxt,
string outputMd, List <Result> results, ServiceInfo service, Language language, ServiceLanguageInfo serviceLanguageInfo,
string languageVersion, IDictionary <string, string> packageVersions)
{
try
{
Console.WriteLine($"SetupAsync({serviceLanguageInfo.Project}, {languageVersion}, " +
$"{JsonSerializer.Serialize(packageVersions)})");
Console.WriteLine();
string setupOutput = null;
string setupError = null;
string context = null;
string setupException = null;
try
{
(setupOutput, setupError, context) = await _languages[language].SetupAsync(
serviceLanguageInfo.Project, languageVersion, packageVersions);
}
catch (Exception e)
{
setupException = e.ToString();
Console.WriteLine(e);
Console.WriteLine();
}
foreach (var test in service.Tests)
{
IEnumerable <string> selectedArguments;
if (!options.NoAsync && !options.NoSync)
{
selectedArguments = test.Arguments.SelectMany(a => new string[] { a, a + " --sync" });
}
else if (!options.NoSync)
{
selectedArguments = test.Arguments.Select(a => a + " --sync");
}
else if (!options.NoAsync)
{
selectedArguments = test.Arguments;
}
else
{
throw new InvalidOperationException("Cannot set both --no-sync and --no-async");
}
foreach (var arguments in selectedArguments)
{
var allArguments = arguments;
if (serviceLanguageInfo.AdditionalArguments != null)
{
foreach (var kvp in serviceLanguageInfo.AdditionalArguments)
{
var(name, value) = (kvp.Key, kvp.Value);
if (arguments == null || !arguments.Contains($"--{name} "))
{
allArguments += $" --{name} {value}";
}
}
}
if (options.Insecure)
{
allArguments += " --insecure";
}
if (options.TestProxies != null && options.TestProxies.Any())
{
allArguments += $" --test-proxies {String.Join(';', options.TestProxies)}";
}
if (options.TestProxy != null)
{
allArguments += $" --test-proxy {options.TestProxy}";
}
var result = new Result
{
Service = service.Service,
Test = test.Test,
Start = DateTime.Now,
Language = language,
LanguageVersion = languageVersion,
Project = serviceLanguageInfo.Project,
LanguageTestName = test.TestNames[language],
Arguments = allArguments,
PrimaryPackage = serviceLanguageInfo.PrimaryPackage,
PackageVersions = packageVersions,
SetupStandardOutput = setupOutput,
SetupStandardError = setupError,
SetupException = setupException,
};
results.Add(result);
await WriteResults(outputJson, outputCsv, outputTxt, outputMd, results);
if (setupException == null)
{
for (var i = 0; i < options.Iterations; i++)
{
IterationResult iterationResult;
try
{
Console.WriteLine($"RunAsync({serviceLanguageInfo.Project}, {languageVersion}, " +
$"{test.TestNames[language]}, {allArguments}, {context})");
Console.WriteLine();
iterationResult = await _languages[language].RunAsync(
serviceLanguageInfo.Project,
languageVersion,
packageVersions,
test.TestNames[language],
allArguments,
context
);
}
catch (Exception e)
{
iterationResult = new IterationResult
{
OperationsPerSecond = double.MinValue,
Exception = e.ToString(),
};
Console.WriteLine(e);
Console.WriteLine();
}
// Replace non-finite values with minvalue, since non-finite values
// are not JSON serializable
if (!double.IsFinite(iterationResult.OperationsPerSecond))
{
iterationResult.OperationsPerSecond = double.MinValue;
}
result.Iterations.Add(iterationResult);
await WriteResults(outputJson, outputCsv, outputTxt, outputMd, results);
}
}
result.End = DateTime.Now;
}
}
}
finally
{
if (!options.NoCleanup)
{
Console.WriteLine($"CleanupAsync({serviceLanguageInfo.Project})");
Console.WriteLine();
try
{
await _languages[language].CleanupAsync(serviceLanguageInfo.Project);
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine();
}
}
}
}
