/// <summary>
/// Creates a person asynchronously.
/// </summary>
/// <returns>Returns a task.</returns>
private static async Task CreatePersonAsync()
{
Console.WriteLine("Please enter the details of the person to create...");
Console.WriteLine("First name:");
var firstName = Console.ReadLine();
Console.WriteLine("Last name:");
var lastName = Console.ReadLine();
var person = new PersonCreateModel(firstName, lastName);
var serializer = new XmlSerializer(typeof(PersonCreateModel));
var memoryStream = new MemoryStream();
serializer.Serialize(memoryStream, person);
var content = Encoding.UTF8.GetString(memoryStream.ToArray());
var resultTask = client.PostAsync("http://localhost:19040/person", new StringContent(content));
Console.WriteLine("Creating person from client application...");
var response = await resultTask;
Console.WriteLine("Response from create operation");
Console.WriteLine(await response.Content.ReadAsStringAsync());
}
public IActionResult Create(PersonCreateModel newPerson)
{
try
{
if (ModelState.IsValid)
{
if (newPerson.PersonConsent)
{
var person = Mapper.Map <PersonCreateModel, Person>(newPerson);
_person.Add(person);
return(RedirectToAction("Index"));
}
}
else
{
return(View(newPerson));
}
}
// catch (Exception err)
catch (Microsoft.EntityFrameworkCore.Storage.RetryLimitExceededException err)
{
ModelState.AddModelError(err.ToString(), "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
////PopulateWorksDropDownList(newPerson.WorkId);
////PopulateNameTitleDropDownList(newPerson.NameTitleId);
////PopulateReligionDropDownList(newPerson.ReligionId);
return(View(newPerson));
}
public async Task AddAsync(PersonCreateModel person)
{
var name = new SqlParameter("@Name", person.Name);
var birthDay = new SqlParameter("@BirthDay", person.BirthDay);
var config = new SqlParameter("@Config", person.Config);
await _dbContext.Database.ExecuteSqlRawAsync("CreatePersonProc @Name, @BirthDay, @Config", name, birthDay, config);
}
public async Task <PersonModel> Map(PersonCreateModel person)
{
var dbPersonId = Guid.NewGuid();
var dbAuthId = Guid.NewGuid();
var dbPerson = new PersonModel()
{
Id = dbPersonId,
LastModify = DateTime.Now,
Email = person.Email,
Name = person.Name,
Surname = person.Surname,
UserName = person.UserName,
Password = person.Password,
AutorizationLevel = new AutorizationLevelModel()
{
Id = Guid.NewGuid(),
CreationDate = DateTime.UtcNow,
ExpirationDate = DateTime.UtcNow.AddDays(30),
}
};
dbPerson.SafeAuthModel = new SafeAuthModel()
{
Id = Guid.NewGuid(),
AutId = dbAuthId,
UserId = dbPersonId,
Control = await _securLib.EncriptLine(await _securLib.EncryptEntityRelation(dbPerson, dbPerson.AutorizationLevel))
};
return(dbPerson);
}
public IActionResult Create(PersonCreateModel newPerson)
{
try
{
if (ModelState.IsValid)
{
if (newPerson.PersonConsent)
{
var person = new Person();
person.FirstName = newPerson.FirstName;
person.MiddleName = newPerson.MiddleName;
person.LastName = newPerson.LastName;
person.ExtensionName = newPerson.ExtensionName;
person.NameTitleId = newPerson.NameTitleId;
person.Sex = newPerson.Sex;
person.DateOfBirth = newPerson.DateOfBirth;
person.CivilStatus = newPerson.CivilStatus;
person.ContactNumber = newPerson.ContactNumber;
person.DateCreated = DateTime.Now;
person.DateTimeLastUpdated = person.DateCreated;
person.PersonConsent = newPerson.PersonConsent;
_person.Add(person);
return(RedirectToAction("Index"));
}
return(View(newPerson));
}
}
catch (Exception err)
{
ModelState.AddModelError(err.ToString(), "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
return(View(newPerson));
}
public async Task AddAsync(PersonCreateModel person)
{
if (person.BirthDay == null || person.BirthDay > DateTime.Today)
{
throw new Exception("تاریخ تولد اجباری است و نمی تواند تاریخ آینده باشد");
}
if (string.IsNullOrWhiteSpace(person.Name))
{
throw new Exception("نام اجباری است");
}
if (string.IsNullOrWhiteSpace(person.Config))
{
throw new Exception("دسترسی اجباری است");
}
else
{
var permissions = JsonConvert.DeserializeObject <Permissions>(person.Config);
if (permissions == null)
{
throw new Exception("دسترسی معتبر نیست");
}
}
await _personRepository.AddAsync(person);
}
public IActionResult Create()
{
PopulateWorksDropDownList();
PopulateNameTitleDropDownList();
PopulateReligionDropDownList();
var model = new PersonCreateModel();
return(View(model));
}
public IActionResult Create(PersonCreateModel personVM)
{
if (ModelState.IsValid)
{
_personService.Add(personVM);
return(RedirectToAction("Index", personListVM));
}
return(View("Index", personListVM));
}
public IActionResult Create(PersonCreateModel personVM)
{
if (ModelState.IsValid)
{
personListVM.PersonList = _personService.CreatePerson(personVM.Name, personVM.City, personVM.Phonenumber);
return(RedirectToAction("Index", personListVM));
}
return(View());
}
public ActionResult Create(int?type_ID, int?subType_ID, bool inMailingListOnly)
{
var model = new PersonCreateModel();
model.filter = new EventsFilterViewModel_ForList
{
Type_ID = type_ID,
SubType_ID = subType_ID,
InMailingListOnly = inMailingListOnly
};
return(View(model));
}
public ActionResult Create(PersonCreateModel model)
{
try
{
PersonOperations.CreateUpdate(model.details, null, "", false);
return(RedirectToAction("Index", new { Type_ID = model.filter.Type_ID, SubType_ID = model.filter.SubType_ID, InMailingListOnly = model.filter.InMailingListOnly }));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
public async Task <ActionResult> CreateAsync([FromBody] PersonCreateModel person)
{
try
{
await _personService.AddAsync(person);
return(Ok());
}
catch (Exception ex)
{
return(ErrorResponse(ex));
}
}
public async Task <ActionResult> Edit(PersonCreateModel entity)
{
try
{
PersonService.Update(entity.ToPerson());
return(RedirectToAction("Index"));
}
catch (Exception e)
{
var message = "Sth went wrong :(. Changes didn't save.";
return(RedirectToAction("Edit", new { entity.Id, message }));
}
}
public ActionResult Create(PersonCreateModel model)
{
try
{
var id = manager.SaveCreateModel(model);
var responseModel = manager.GetDetailsModel(id);
return(CreatedAtAction(nameof(Details), new { personId = id }, responseModel));
}
catch (Exception ex)
{
return(Problem());
}
}
public static Person ToPerson(this PersonCreateModel entity)
{
if (entity == null)
{
return(null);
}
return(new Person
{
FirstName = entity.FirstName,
SecondName = entity.MiddleName,
LastName = entity.LastName,
SerialNumber = entity.SerialNumber
});
}
public async Task <IActionResult> CreateUser([FromBody] PersonCreateModel usr, [FromBody] AutorizationLevelCreateModel auth)
{
try
{
if (usr == null || auth == null)
{
return(BadRequest());
}
var created = await _personService.Create(usr, auth);
return(Ok(created));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public long SaveCreateModel(PersonCreateModel model)
{
var item = new Person
{
Id = 890123, //TODO generate Ids
CompanyId = model.CompanyId,
Forename = model.Forename,
Surname = model.Surname,
Email = model.Email,
JobTitle = model.JobTitle,
MobileNumber = model.MobileNumber,
TelephoneNumber = model.TelephoneNumber
};
dc.People.Add(item);
//dc.Save();
return(item.Id);
}
public async Task <HttpResponseMessage> Add([FromBody] PersonCreateModel model)
{
HttpResponseMessage returnMessage = new HttpResponseMessage();
var personEditDto = mapper.Map <PersonEditDto>(model);
var result = await personSkillService.CreateAsync(personEditDto);
if (result.IsSuccess)
{
string message = ($"Person Created - {result.Entity.Id}");
returnMessage = new HttpResponseMessage(HttpStatusCode.Created);
returnMessage.RequestMessage = new HttpRequestMessage(HttpMethod.Post, message);
}
else
{
returnMessage = new HttpResponseMessage(HttpStatusCode.ExpectationFailed);
returnMessage.RequestMessage = new HttpRequestMessage(HttpMethod.Post, result.GetErrorString());
}
return(returnMessage);
}
public async Task <Guid> Create(PersonCreateModel person, AutorizationLevelCreateModel autorizationLevel)
{
try
{
if (person == null || autorizationLevel == null)
{
return(Guid.Empty);
}
var dbPerson = await _personCreateModelToPersonModelConverter.Map(person).ConfigureAwait(false);
_context.Persons.Add(dbPerson);
_context.Autorizations.Add(dbPerson.AutorizationLevel);
_context.SafeAuthModels.Add(dbPerson.SafeAuthModel);
_context.SaveChanges();
return(dbPerson.Id);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized od person", MethodBase.GetCurrentMethod(), ex);
return(Guid.Empty);
}
}
/// <summary>
/// </summary>
/// <returns></returns>
public async Task CreateAdmin()
{
try
{
var card = new CardCreateModel()
{
CardNumber = "123456",
ExpirationDate = DateTime.UtcNow.AddYears(1),
};
var usr = new PersonCreateModel()
{
UserName = "******",
Email = "*****@*****.**",
Password = await _securLib.EncriptLine("Admin"),
};
var auth = new AutorizationLevelCreateModel()
{
AuthName = "ROOT",
AuthValue = WellknownAuthorizationLevel.Root,
ExpirationDate = DateTime.UtcNow.AddYears(1)
};
await Create(usr, auth);
var menu = _menuService.CreateMenuFromPages();
foreach (var vm in menu)
{
vm.AuthLevel = WellknownAuthorizationLevel.User;
}
_context.MainMenu.AddRange(menu);
_context.SaveChanges();
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized of person", MethodBase.GetCurrentMethod(), ex);
}
}
public IActionResult Create()
{
PersonCreateModel newPerson = new PersonCreateModel();
return(View(newPerson));
}
public IActionResult Create(
PersonCreateModel createModel)
{
//
// Validate
//
// Abort if something is wrong
if (!ModelState.IsValid)
{
return(View(createModel));
}
//
// Create
//
var newPerson = new Person();
newPerson.Gender = (PersonGender)createModel.Gender;
try
{
_personData.AddPerson(newPerson);
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError(
"",
"Unable to add person. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
return(View(createModel));
}
//
// Update RDF
//
_rdfData.AddOrUpdatePerson(newPerson);
//
// Update search index
//
var persons = new List <PersonDocumentCreateModel>
{
// When creating a person we only have
// PersonGuid and Gender.
new PersonDocumentCreateModel
{
PersonGuid = newPerson.PersonGuid.ToString(),
Gender = newPerson.Gender.ToString()
}
};
// TODO try catch to handle errors
_personSearchIndex.UploadDocuments(persons);
//
// Redirect
//
return(RedirectToAction(
"Details",
"Person",
new { personGuid = newPerson.PersonGuid }));
}
public Person Add(PersonCreateModel personCreateModel)
{
return(_personRepo.Create(personCreateModel.Name, personCreateModel.City, personCreateModel.Phonenumber));
}
public CreatePersonCommand(PersonCreateModel model, IMediator mediator)
{
Model = model;
_mediator = mediator;
}
static async Task Main(string[] args)
{
var mysplitURL = new Uri("https://localhost:44384/Service/MySplit?text=Hello World");
var createURL = new Uri("https://localhost:44384/Service/Create");
var getPersonsURL = new Uri("https://localhost:44384/Service/Get");
using (var client = new HttpClient())
{
for (int i = 0; i < 10; i++)
{
var response = await client.GetAsync(mysplitURL);
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine($"MySplit response: {responseBody}");
if (i == 4)
{
mysplitURL = new Uri("https://localhost:44384/Service/MySplit?tex = wad");
}
}
var person = new PersonCreateModel
{
Iin = "123456789102",
Birthday = DateTime.Now,
FirstName = "Макар",
LastName = "Макаров",
MiddleName = "Ильясович"
};
var random = new Random();
for (int i = 0; i < 10; i++)
{
string iin = "";
var json = JsonConvert.SerializeObject(person);
var response = await client.PostAsync(createURL, new StringContent(json, Encoding.UTF8, "application/json"));
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine($"Create person response: {responseBody}");
for (int j = 0; j < 12; j++)
{
iin += random.Next(1, 9).ToString();
}
person.Iin = iin;
if (i == 2)
{
person.Iin = "123456789102";
}
else if (i == 4)
{
person.FirstName = null;
}
else if (i == 7)
{
person.FirstName = "Андрей";
}
}
var res = await client.GetAsync(getPersonsURL);
var resBody = await res.Content.ReadAsStringAsync();
Console.WriteLine($"Get response: {resBody}");
}
}
