public async Task <IHttpActionResult> PostCensus(Census census)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (census.ImageArray != null && census.ImageArray.Length > 0)
{
var stream = new MemoryStream(census.ImageArray);
var guid = Guid.NewGuid().ToString();
var file = $"{guid}.jpg";
var folder = "~/Content/Censuses";
var fullPath = $"{folder}/{file}";
var response = FilesHelper.UploadPhoto(stream, folder, file);
if (response)
{
census.ImagePath = fullPath;
}
}
db.Census.Add(census);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = census.CensusId }, census));
}
public static List <CensusNode> GetCensus(this DotNS api, string name, Census stat, long fromTS = -1, long toTS = -1)
{
var nvc = new NameValueCollection();
nvc.Add("nation", name);
if (fromTS != -1 && toTS == -1)
{
toTS = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}
nvc.Add("q", $"census;scale={(int)stat};mode=history{(fromTS != -1 ? $";from={fromTS};to={toTS}" : "")}");
var resp = Utilities.API(nvc, null, 0, api.UserAgent);
string xml = Utilities.StrResp(resp);
var nodelist = Utilities.Parse(xml, "/NATION/CENSUS/SCALE/*");
List <CensusNode> nodes = new List <CensusNode>();
foreach (XmlNode node in nodelist)
{
long timestamp = long.Parse(node.FirstChild.InnerText);
double score = double.Parse(node.LastChild.InnerText, CultureInfo.InvariantCulture);
var tn = new CensusNode();
tn.timestamp = timestamp;
tn.value = score;
nodes.Add(tn);
}
return(nodes);
}
private Census BuildCensusResults(
Dictionary <string, AggregateQuery> aggregateQueries,
DbDataReader dbDataReader)
{
Census toReturn = null;
// Extract the field names in the result set.
List <string> resultSetFieldNames =
GetResultSetFieldNames(dbDataReader);
IAggregator[] aggregators = aggregateQueries
.Select(x => this.aggregatorFactory.Create(
resultSetFieldNames,
x.Key,
x.Value))
.ToArray();
this.loggerWrapper.Info(
$"{aggregators.Length} {nameof(IAggregator)}s created. " +
$"Cycling through rows...");
int rowNumber = 0;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
while (dbDataReader.Read())
{
foreach (IAggregator aggregator in aggregators)
{
aggregator.ProcessRow(dbDataReader);
}
rowNumber++;
}
stopwatch.Stop();
TimeSpan elapsed = stopwatch.Elapsed;
this.loggerWrapper.Info(
$"{rowNumber} row(s) cycled through in {elapsed}.");
this.loggerWrapper.Debug(
$"Quizzing {nameof(IAggregator)}s for results...");
Aggregation[] aggregations = aggregators
.Select(x => x.GetResult())
.ToArray();
this.loggerWrapper.Info(
$"{aggregations.Length} {nameof(Aggregation)}(s) returned.");
toReturn = new Census()
{
_Aggregations = aggregations.ToArray(),
};
return(toReturn);
}
partial void ViewInvalidClicked(NSObject sender)
{
Census census = new Census(CensusDate.ANYCENSUS, true);
census.SetupLCupdateList(LCInvalidReferences);
census.ShowWindow($"Incompatible Census References in Records to upload to Lost Cousins Website");
Analytics.TrackAction(Analytics.LostCousinsAction, Analytics.PreviewLostCousins);
}
partial void ViewPotentialClicked(NSObject sender)
{
Census census = new Census(CensusDate.ANYCENSUS, true);
census.SetupLCupdateList(LCUpdates);
census.ShowWindow($"Potential Records to upload to Lost Cousins Website");
Analytics.TrackAction(Analytics.LostCousinsAction, Analytics.PreviewLostCousins);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Census census = await db.Census.FindAsync(id);
db.Census.Remove(census);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public bool IsValid(Census census)
{
if (string.IsNullOrEmpty(census.EffectiveDate) && string.IsNullOrEmpty(census.DeletionDate))
{
return(false);
}
return(Convert.ToDateTime(census.EffectiveDate) < Convert.ToDateTime(census.DeletionDate));
}
public async Task <Result> ProcessAsync(Census census)
{
var processors = _censusProcessorTypes.Select(t => (ICensusProcessor)Activator.CreateInstance(t, census)).ToList();
return(await processors
.Single(processor => processor.CanProcessType())
.ProcessAsync()
.ConfigureAwait(false));
}
public async Task <IHttpActionResult> GetCensus(int id)
{
Census census = await db.Census.FindAsync(id);
if (census == null)
{
return(NotFound());
}
return(Ok(census));
}
public async Task <ActionResult> Edit(Census census)
{
if (ModelState.IsValid)
{
db.Entry(census).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(census));
}
public async Task <ActionResult> Create(Census census)
{
if (ModelState.IsValid)
{
db.Census.Add(census);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(census));
}
private int ActualArrivals()
{
int max = newCitizensNum;
int freeRooms = HousingMarket.GetVacantPlacesNum();
int alarmLimit = max;
if (Census.GetCitizensNum() > 9 && (ResourceHolder.FoodAlarmLast3Days() || ResourceHolder.WaterAlarmLast3Days()))
{
alarmLimit = Mathf.FloorToInt(max * 0.25f);
}
return(Min(freeRooms, alarmLimit, max));
}
private void SpawnNew()
{
var posY = citizenPrefab.transform.position.y;
var newC = Instantiate(citizenPrefab, exit.transform.position, Quaternion.identity);
newC.transform.position = new Vector3(newC.transform.position.x, posY, newC.transform.position.z);
var name = names[spawnedCitizen];
newC.GetComponent <Citizen>().SetName(name);
spawnedCitizen++;
Census.AddCitizen(newC.GetComponent <Citizen>());
ToastBox.ShowMsg(newC.GetComponent <Citizen>().Name() + " arrived.");
}
public bool IsValid(Census census)
{
int gender = 0;
foreach (var key in Enum.GetNames(typeof(Gender)))
{
if (string.Equals(key, census.Gender, StringComparison.CurrentCultureIgnoreCase))
{
gender = (int)Enum.Parse(typeof(Gender), key);
break;
}
}
return(gender != 0);
}
public async Task <IHttpActionResult> DeleteCensus(int id)
{
Census census = await db.Census.FindAsync(id);
if (census == null)
{
return(NotFound());
}
db.Census.Remove(census);
await db.SaveChangesAsync();
return(Ok(census));
}
// GET: Censuses/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Census census = await db.Census.FindAsync(id);
if (census == null)
{
return(HttpNotFound());
}
return(View(census));
}
public bool Validate(Census census)
{
bool isCensusValid = false;
foreach (var validator in _validatorInstances)
{
if (isCensusValid)
{
isCensusValid = validator.IsValid(census);
}
}
return(isCensusValid);
}
public IActionResult Create(Census census)
{
string status = "";
var censusToSave = new Census
{
DateTime = census.DateTime,
Department = census.Department,
PatientCount = census.PatientCount
};
_context.Censuses.Add(censusToSave);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> PutCensus(int id, Census census)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != census.CensusId)
{
return(BadRequest());
}
if (census.ImageArray != null && census.ImageArray.Length > 0)
{
var stream = new MemoryStream(census.ImageArray);
var guid = Guid.NewGuid().ToString();
var file = $"{guid}.jpg";
var folder = "~/Content/Censuses";
var fullPath = $"{folder}/{file}";
var response = FilesHelper.UploadPhoto(stream, folder, file);
if (response)
{
census.ImagePath = fullPath;
}
}
db.Entry(census).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CensusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(census));
}
void LostCousinsCensus(CensusDate censusDate, string reportTitle)
{
Census census = new Census(censusDate, true);
Predicate <CensusIndividual> relationFilter = RelationshipTypesOutlet.BuildFilter <CensusIndividual>(x => x.RelationType);
Predicate <Individual> individualRelationFilter = RelationshipTypesOutlet.BuildFilter <Individual>(x => x.RelationType);
census.SetupLCCensus(relationFilter, ShowAlreadyEnteredOutlet.State == NSCellStateValue.On, individualRelationFilter);
if (ShowAlreadyEnteredOutlet.State == NSCellStateValue.On)
{
census.ShowWindow($"{reportTitle} already entered into Lost Cousins website (includes entries with no country)");
}
else
{
census.ShowWindow($"{reportTitle} to enter into Lost Cousins website");
}
Task.Run(() => Analytics.TrackActionAsync(Analytics.LostCousinsAction, Analytics.LCReportYearEvent, censusDate.BestYear.ToString()));
}
public static async Task <Result> ProcessTestCensus()
{
var testCensus = new Census()
{
EffectiveDate = "11/8/2018",
DeletionDate = "11/8/2019",
DateOfBirth = "10/15/1992",
Gender = "Male",
Email = "*****@*****.**",
ProcessType = ProcessType.S
};
var factory = new CensusProcessorFactory();
return(await factory
.ProcessAsync(testCensus)
.ConfigureAwait(false));
}
private void Die(string reason)
{
if (currentBuilding)
{
currentBuilding.CheckOut(this);
}
if (home != null)
{
home.GetComponent <Housing>().RemoveResident(this);
}
if (firstWork != null)
{
firstWork.GetComponent <Factory>().RemoveEmployee(this);
}
Census.RemoveCitizen(this);
ToastBox.ShowMsg(citizenName + " died because of " + reason);
Destroy(gameObject);
}
static void Main(string[] args)
{
String lastCommand;
bool Done = false;
Census myCensus = new Census();
Console.Out.WriteLine("Copyright (c) 2015 Caprica LLC - c# shell\n");
Console.Out.WriteLine("Loading wallet information...\n");
Console.Out.WriteLine(myCensus.doLoadWallet("c:\\temp\\config.json"));
while ( ! Done)
{
System.Console.Write("census> ");
lastCommand = System.Console.ReadLine();
if (lastCommand == "done") Environment.Exit(1);
if (lastCommand == "login") Console.Out.WriteLine(myCensus.doLogin());
if (lastCommand == "version") Console.Out.WriteLine(myCensus.doVersion());
if (lastCommand == "newwallet") Console.Out.WriteLine(myCensus.doNewWallet());
}
}
/// <inheritdoc />
public async Task <Census> GetCensusAsync(
IEnumerable <string> aggregationFields,
DatasetQueryFile datasetQueryFile,
Dictionary <string, AggregateQuery> aggregateQueries,
string parameterName,
string parameterValue,
BuildCensusResultsCallback buildCensusResultsCallback,
CancellationToken cancellationToken)
{
Census toReturn = null;
if (datasetQueryFile == null)
{
throw new ArgumentNullException(nameof(datasetQueryFile));
}
if (buildCensusResultsCallback == null)
{
throw new ArgumentNullException(
nameof(buildCensusResultsCallback));
}
QueryConfiguration queryConfiguration =
datasetQueryFile.QueryConfiguration;
string connectionString = this.GetConnectionString(
queryConfiguration);
string query = datasetQueryFile.Query;
toReturn = await this.ExecuteQueryAsync(
aggregationFields,
aggregateQueries,
connectionString,
query,
parameterName,
parameterValue,
buildCensusResultsCallback,
cancellationToken)
.ConfigureAwait(false);
return(toReturn);
}
public bool IsValid(Census census)
{
const string domainRegexp = "(@)(.+)$";
const string emailRegxp =
@"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[\w])@))" +
@"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$";
// Use IdnMapping class to convert Unicode domain names.
try
{
census.Email = Regex.Replace(
census.Email,
domainRegexp,
IdnMapper,
RegexOptions.None,
TimeSpan.FromMilliseconds(200));
}
catch (RegexMatchTimeoutException)
{
return(false);
}
if (_invalid)
{
return(false);
}
// Return true if strIn is in valid email format.
try
{
return(Regex.IsMatch(
census.Email,
emailRegxp,
RegexOptions.IgnoreCase,
TimeSpan.FromMilliseconds(250)));
}
catch (RegexMatchTimeoutException)
{
return(false);
}
}
void Update()
{
if (activeEntries == Census.GetCitizensNum())
{
return;
}
foreach (Transform child in contentView.transform)
{
Destroy(child.gameObject);
}
var citizens = Census.GetCitizens();
activeEntries = citizens.Count;
for (int i = 0; i < citizens.Count; i++)
{
var entry = Instantiate(prefab);
entry.transform.SetParent(contentView.transform, false);
entry.GetComponent <CitizenInfoElement>().SetCitizen(citizens[i], i + 1);
}
}
public async Task ThenItShouldReturnSquashedEntity(Census census)
{
_entityRepositoryMock.Setup(r => r.LoadCensusAsync(
It.IsAny <LoadCensusRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new EntityCollection <Census>
{
SquashedEntityResults = new[]
{
new SquashedEntityResult <Census>
{
SquashedEntity = census,
},
},
});
var context = BuildManagementGroupResolveFieldContext();
var actual = await _censusResolver.ResolveAsync(context);
Assert.IsNotNull(actual);
Assert.AreSame(census, actual);
_entityRepositoryMock.Verify(r => r.LoadCensusAsync(
It.IsAny <LoadCensusRequest>(), It.IsAny <CancellationToken>()),
Times.Once());
}
/// <inheritdoc />
public async Task <GetCensusesResponse> GetCensusesAsync(
GetCensusesRequest getCensusesRequest,
CancellationToken cancellationToken)
{
var censuses = new Census[getCensusesRequest.CensusIdentifiers.Length];
for (var i = 0; i < censuses.Length; i++)
{
var singleRequest = new GetCensusRequest
{
CensusIdentifier = getCensusesRequest.CensusIdentifiers[i],
AggregateQueries = getCensusesRequest.AggregateQueries,
};
var singleResponse = await GetCensusAsync(singleRequest, cancellationToken);
censuses[i] = singleResponse.Census;
}
return(new GetCensusesResponse
{
Censuses = censuses,
});
}
protected BaseCensusProcessor(Census census)
{
_census = census;
}
public CensusSuspensionProcessor(Census census) : base(census)
{
}
public CensusInclusionProcessor(Census census) : base(census)
{
}