static void Main(string[] args)
{
Console.WriteLine("Practices of event aggregator");
//IEventAggregator ea = new SimpleEventAggregator();
//var service = new PersonService(ea);
var ea = InstanceFactory.EventAggregator;
var pCreate = new PersonCreate(new Person()
{
Id = 3, LastName = "Test", FirstName = "Sally"
});
var pDelete = new PersonDelete(new Person()
{
Id = 5, LastName = "Test", FirstName = "Dora"
});
var pEdit = new PersonEdit(new Person()
{
Id = 9, LastName = "Test", FirstName = "Thomas"
});
ea.Publish(pCreate);
ea.Publish(pDelete);
ea.Publish(pEdit);
Console.ReadLine();
}
/// <inheritdoc />
public async Task DeleteAsync(string id, CancellationToken token = new CancellationToken())
{
var serverId = MapperHelper.MapToType <Guid, string>(id);
var item = new PersonCreate();
await UpdateAddressesAsync(serverId, item, token);
await _storage.Person.DeleteAsync(serverId, token);
}
public void Start()
{
var flag = true;
var helloBanner = File.ReadAllLines("TextFile1.txt", Encoding.Default);
foreach (var symbol in helloBanner)
{
Console.WriteLine($"{symbol}");
}
while (flag)
{
Console.WriteLine($"\nYou have an options:\n1) Add a new member in table;\n" +
$"2) Run Secret Santa choosing process;\n3) Find out to whom you're giving a gift;\n" +
$"4) View list of participants;\n5) Delete someone from table;\n6) Delete whole table;\n" +
$"7) Exit SS app.\n\nChoose number of option:");
var choosenOption = int.Parse(Console.ReadLine());
switch (choosenOption)
{
case 1:
PersonCreate person = new PersonCreate();
person.CreatePerson();
break;
case 2:
ChooseGiftRecipient choose = new ChooseGiftRecipient();
choose.Choose();
break;
case 3:
ShowRecipient show = new ShowRecipient();
show.ShowMan();
break;
case 4:
ShowTable showTable = new ShowTable();
showTable.ShowTableOfPersons();
break;
case 5:
Delete deleteOneOption = new Delete();
deleteOneOption.DeletePerson();
break;
case 6:
Delete deleteAllOption = new Delete();
deleteAllOption.DeleteAll();
break;
case 7:
flag = false;
Console.WriteLine($"Good bye!!!");
System.Threading.Thread.Sleep(1000);
break;
}
}
}
// GET: Person/Create
public ActionResult Create(string personGroupId)
{
var vm = new PersonCreate()
{
PersonGroupId = personGroupId,
Person = new Person()
};
return(View(vm));
}
/// <inheritdoc />
public async Task <string> CreateAsync(PersonCreate item, CancellationToken token = new CancellationToken())
{
var record = await MapToServerAsync(item, token);
record = await _storage.Person.CreateAndReturnAsync(record, token);
FulcrumAssert.IsValidated(record);
FulcrumAssert.IsNotDefaultValue(record.Id);
await UpdateAddressesAsync(record.Id, item, token);
return(MapperHelper.MapToType <string, Guid>(record.Id));
}
private async Task <PersonTable> MapToServerAsync(PersonCreate source, CancellationToken token = default(CancellationToken))
{
InternalContract.RequireNotNull(source, nameof(source));
InternalContract.RequireValidated(source, nameof(source));
var target = new PersonTable
{
Name = source.Name
};
FulcrumAssert.IsValidated(target);
return(await Task.FromResult(target));
}
// GET: Person/Details/5
public async Task <ActionResult> Details(string id, string personGroupId)
{
var person = await _personRep.GetPerson(personGroupId, id);
var vm = new PersonCreate()
{
PersonGroupId = personGroupId,
Person = person
};
return(View(vm));
}
/// <summary>
/// Creates a new Person in the database.
/// </summary>
/// <param name="person"></param>
///
/// <returns></returns>
public IHttpActionResult Post(PersonCreate person)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreatePersonService();
if (!service.CreatePerson(person))
{
return(InternalServerError());
}
return(Ok());
}
public async Task <IActionResult> AddPerson([FromBody] PersonCreate person)
{
if (ModelState.IsValid)
{
Person personConverted = person.ConvertPersonWhenCreate();
await _personRepository.AddPerson(personConverted, person.Password);
return(Ok(personConverted.ConvertPersonToShowSingle()));
}
else
{
return(BadRequest());
}
}
public bool CreatePerson(PersonCreate model)
{
var entity =
new Person()
{
OwnerID = _userID,
FirstName = model.FirstName,
LastName = model.LastName,
FullName = model.FullName
};
using (var ctx = new ApplicationDbContext())
{
ctx.Person.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public bool CreatePerson(PersonCreate model)
{
var entity =
new Person()
{
UserId = _userId,
FirstName = model.FirstName,
LastName = model.LastName,
HowKnown = model.HowKnown,
};
using (var ctx = new ApplicationDbContext())
{
ctx.People.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
//Create//
public bool PersonCreate(PersonCreate model)
{
var entity =
new Person()
{
OwnerID = _userID,
Name = model.Name,
Title = model.Title,
Age = model.Age,
Occupation = model.Occupation,
PlaceID = model.Place,
EquippedArtifact = model.EquippedArtifact
};
_context.Persons.Add(entity);
return(_context.SaveChanges() == 1);
}
public bool CreatePerson(PersonCreate model)
{
var entity =
new Person()
{
OwnerId = _userId,
Name = model.Name,
Weight = model.Weight,
HealthGoals = model.HealthGoals,
DateStarted = model.DateStarted
};
using (var ctx = new ApplicationDbContext())
{
ctx.Persons.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public bool CreatePerson(PersonCreate model)
{
var entity =
new Person()
{
UserID = _userId,
Name = model.Name,
Email = model.Email,
Role = model.Role,
DateJoined = model.DateJoined
};
using (var ctx = new ApplicationDbContext())
{
ctx.Persons.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public ActionResult Create(PersonCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreatePersonService();
if (service.CreatePerson(model))
{
TempData["SaveResult"] = "Person was created.";
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "New Person could not be created.");
return(View(model));
}
private async Task UpdateAddressesAsync(Guid personId, PersonCreate person, CancellationToken token)
{
var serverAddresses = await _storage.Address.ReadChildrenAsync(personId, token : token);
var serverAddressArray = serverAddresses as AddressTable[] ?? serverAddresses.ToArray();
var tasks = new List <Task>();
for (var typeInt = 1; typeInt < 5; typeInt++)
{
var typeString = MapperHelper.MapToType <string, int>(typeInt);
var serverAddress = serverAddressArray.FirstOrDefault(a => a.Type == typeInt);
var address = person.Addresses.FirstOrDefault(a => a.Type == typeString);
if (serverAddress == null)
{
if (address == null)
{
continue;
}
serverAddress = ToServer(personId, address);
var task = _storage.Address.CreateAsync(serverAddress, token);
tasks.Add(task);
}
else
{
Task task;
if (address == null)
{
task = _storage.Address.DeleteAsync(serverAddress.Id, token);
}
else
{
var updatedServerAddress = ToServer(personId, address);
updatedServerAddress.Id = serverAddress.Id;
updatedServerAddress.Etag = serverAddress.Etag;
task = _storage.Address.UpdateAsync(updatedServerAddress.Id, updatedServerAddress, token);
}
tasks.Add(task);
}
}
await Task.WhenAll(tasks);
}
public static Person ConvertPersonWhenCreate(this PersonCreate person)
{
return(new Person
{
UserName = person.Email,
Name = person.Name,
Surname = person.Surname,
BornAt = person.BornAt,
CreatedAt = DateTime.Now,
Email = person.Email,
PhoneNumber = person.PhoneNumber,
Details = person.Details,
Address = person.Address,
IsEmployed = person.IsEmployed,
Company = person.Company,
MoneyToLend = person.MoneyToLend,
MoneyToBorrow = person.MoneyToBorrow,
WaitingTime = person.WaitingTime,
LendOnlyToEmployed = person.LendOnlyToEmployed,
RequiresAddress = person.RequiresAddress,
MaxAmountOfMoney = person.MaxAmountOfMoney
});
}
private static void PersonCreateHandler(PersonCreate personCreate)
{
Console.WriteLine($"------- ----- {personCreate.Id}");
}
