public int Insert(PersonAddRequest model)
{
int id = 0;
using (SqlConnection conn = new SqlConnection(connString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("Person_Insert", conn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@FirstName", model.FirstName);
cmd.Parameters.AddWithValue("@MiddleName", model.MiddleName);
cmd.Parameters.AddWithValue("@LastName", model.LastName);
cmd.Parameters.AddWithValue("@DOB", model.DOB);
cmd.Parameters.AddWithValue("@ModifiedBy", model.ModifiedBy);
SqlParameter parm = new SqlParameter("@Id", SqlDbType.Int);
parm.Direction = ParameterDirection.Output;
cmd.Parameters.Add(parm);
cmd.ExecuteNonQuery();
id = (int)cmd.Parameters["@Id"].Value;
}
conn.Close();
}
return(id);
}
public async Task <Guid> Execute(PersonAddRequest person)
{
var entity = mapper.Map <Person>(person);
await personRepository.Add(entity);
return(entity.Id);
}
public void Update(PersonAddRequest model)
{
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
string sqlCmd = "Person_Update";
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter parm = new SqlParameter();
cmd.Parameters.AddWithValue("@Id", model.Id);
cmd.Parameters.AddWithValue("@FirstName", model.Name);
cmd.Parameters.AddWithValue("@Email", model.Email);
cmd.Parameters.AddWithValue("@Password", model.Password);
cmd.ExecuteNonQuery();
}
}
}
}
public HttpResponseMessage ConfirmToken(String userId, Guid guid)
{
SecurityToken securityToken = SecurityTokenService.SelectByGuid(guid);
if (securityToken.AspNetUserId != null && securityToken.AspNetUserId == userId)
{
DateTime now = DateTime.UtcNow;
TimeSpan daysElapsed = (now - securityToken.DateCreated);
if (daysElapsed.TotalDays > 1)
{
String errorMessage = "1|Not activated in 24 hours";
ErrorResponse response = new ErrorResponse(errorMessage);
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, response));
}
else
{
UserService.ConfirmEmail(securityToken.AspNetUserId);
if (!PersonService.CheckIfPerson(securityToken.AspNetUserId))
{
PersonAddRequest person = new PersonAddRequest();
person.Email = securityToken.Email;
person.AspNetUserId = securityToken.AspNetUserId;
int id = PersonService.Insert(person);
}
SuccessResponse response = new SuccessResponse();
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
}
else
{
String errorMessage = "2|Confirm failed";
ErrorResponse response = new ErrorResponse(errorMessage);
return(Request.CreateResponse(HttpStatusCode.BadRequest, response));
}
}
public static int Insert(PersonAddRequest model)
{
int id = 0;
using (SqlConnection conn = new SqlConnection(WebConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "dbo.Person_Insert";
cmd.Parameters.AddWithValue("@Email", model.Email);
cmd.Parameters.AddWithValue("@AspNetUserId", model.AspNetUserId);
SqlParameter outputId = new SqlParameter("@Id", System.Data.SqlDbType.Int)
{
Direction = System.Data.ParameterDirection.Output
};
cmd.Parameters.Add(outputId);
cmd.ExecuteNonQuery();
id = (int)outputId.Value;
}
conn.Close();
}
return(id);
}
public HttpResponseMessage Post(PersonAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
SuccessResponse response = new SuccessResponse();
_svc.Post(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public HttpResponseMessage CreateGoogleUser(PersonAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
response.Item = _personService.Insert_GoogleUser(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public HttpResponseMessage Add(PersonAddRequest model)
{
if (!ModelState.IsValid && model != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
try
{
ItemResponse <int> response = new ItemResponse <int>();
response.Item = _personService.Insert(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public void Post(PersonAddRequest model)
{
using (var con = new SqlConnection(ConfigurationManager.ConnectionStrings["ViaConnection"].ConnectionString))
{
con.Open();
SqlCommand cmd = con.CreateCommand();
cmd.CommandText = "dbo.Person_Insert";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@FullName", model.FullName);
cmd.Parameters.AddWithValue("@Address", model.Address);
cmd.Parameters.AddWithValue("@Phone", model.Phone);
cmd.ExecuteNonQuery();
}
}
//private IPrincipal _principal;
//private const int HASH_ITERATION_COUNT = 1;
//private const int RAND_LENGTH = 15;
//private ICryptographyService _cryptographyService;
//public PersonService()
//{
//}
//public PersonService(ICryptographyService cryptographyService)
//{
// _cryptographyService = cryptographyService;
//}
public int?Insert(PersonAddRequest model)
{
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
//string salt;
//string passwordHash;
//string password = model.Password;
string sqlCmd = "Person_Insert";
//salt = _cryptographyService.GenerateRandomString(RAND_LENGTH);
//passwordHash = _cryptographyService.Hash(password, salt, HASH_ITERATION_COUNT);
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter parm = new SqlParameter();
parm.SqlDbType = System.Data.SqlDbType.Int;
parm.Direction = System.Data.ParameterDirection.Output;
parm.ParameterName = "@Id";
cmd.Parameters.Add(parm);
cmd.Parameters.AddWithValue("@FirstName", model.Name);
cmd.Parameters.AddWithValue("@Email", model.Email);
cmd.Parameters.AddWithValue("@Password", model.Password);
//cmd.Parameters.AddWithValue("@Salt", mode);
cmd.ExecuteNonQuery();
int id = (int)cmd.Parameters["@Id"].Value;
return(id);
}
}
else
{
return(null);
}
}
}
public int Insert(PersonAddRequest model)
{
int id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Person_Insert",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
MapCommonParameters(model, paramCollection);
SqlParameter outputParam = new SqlParameter("@Id", SqlDbType.Int);
outputParam.Direction = ParameterDirection.Output;
paramCollection.Add(outputParam);
}, returnParameters : delegate(SqlParameterCollection param)
{
Int32.TryParse(param["@Id"].Value.ToString(), out id);
}
);
return(id);
}
public HttpResponseMessage Post(PersonAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
model.ModifiedBy = HttpContext.Current.User.Identity.Name;
}
else
{
model.ModifiedBy = "Anonymous";
}
response.Item = personService.Insert(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
//POST / Create
public int Insert(PersonAddRequest model)
{
int perId = 0;
DataProvider.ExecuteNonQuery("dbo.People_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("FirstName", model.FirstName);
paramCollection.AddWithValue("MiddleName", model.MiddleName);
paramCollection.AddWithValue("LastName", model.LastName);
paramCollection.AddWithValue("ModifiedBy", model.ModifiedBy);
SqlParameter idParameter = new SqlParameter("@UserId", System.Data.SqlDbType.Int);
idParameter.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(idParameter);
}, returnParameters : delegate(SqlParameterCollection param)
{
Int32.TryParse(param["@UserId"].Value.ToString(), out perId);
}
);
return(perId);
}
public int Insert_GoogleUser(PersonAddRequest model)
{
int id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Person_Insert_Google_LogIn",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@FirstName", model.FirstName);
paramCollection.AddWithValue("@LastName", model.LastName);
paramCollection.AddWithValue("@Email", model.Email);
SqlParameter outputParam = new SqlParameter("@Id", SqlDbType.Int);
outputParam.Direction = ParameterDirection.Output;
paramCollection.Add(outputParam);
}, returnParameters : delegate(SqlParameterCollection param)
{
Int32.TryParse(param["@Id"].Value.ToString(), out id);
}
);
return(id);
}
public HttpResponseMessage Register(PersonAddRequest model)
{
try
{
if (ModelState.IsValid)
{
PersonService svc = new PersonService();
int? id = svc.Insert(model);
ItemResponse <int?> resp = new ItemResponse <int?>();
resp.Item = id;
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public async Task <IActionResult> Add([FromBody] PersonAddRequest request) => _presenter.GetActionResult(await _sender.Send(request));
public IActionResult Post([FromBody] PersonAddRequest request)
{
// This won't be hit.
return(Ok());
}
private void MapCommonParameters(PersonAddRequest model, SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@FirstName", model.FirstName);
paramCollection.AddWithValue("@MiddleName", model.MiddleName);
paramCollection.AddWithValue("@LastName", model.LastName);
paramCollection.AddWithValue("@PhoneNumber", model.PhoneNumber);
paramCollection.AddWithValue("@Email", model.Email);
paramCollection.AddWithValue("@JobTitle", model.JobTitle);
paramCollection.AddWithValue("@DateOfBirth", model.DateOfBirth);
paramCollection.AddWithValue("@Address1", model.Address1);
paramCollection.AddWithValue("@Address2", model.Address2);
paramCollection.AddWithValue("@City", model.City);
paramCollection.AddWithValue("@StateProvinceId", model.StateProvinceId);
paramCollection.AddWithValue("@PostalCode", model.PostalCode);
paramCollection.AddWithValue("@CountryId", model.CountryId);
paramCollection.AddWithValue("@IsVeteran", model.IsVeteran);
paramCollection.AddWithValue("@IsEmployer", model.IsEmployer);
paramCollection.AddWithValue("@IsFamilyMember", model.IsFamilyMember);
paramCollection.AddWithValue("@Description", model.Description);
paramCollection.AddWithValue("@EmploymentStatus", model.EmploymentStatus);
paramCollection.AddWithValue("@IsEmployed", model.IsEmployed);
paramCollection.AddWithValue("@OpCodeEmployAssist", model.OpCodeEmployAssist);
paramCollection.AddWithValue("@EducationLevelId", model.EducationLevelId);
if (model.ServiceBranchId > 0)
{
paramCollection.AddWithValue("@ServiceBranchId", model.ServiceBranchId);
}
paramCollection.AddWithValue("@IsPhonePublic", model.IsPhonePublic);
paramCollection.AddWithValue("@IsAddressPublic", model.IsAddressPubic);
paramCollection.AddWithValue("@IsEmailPublic", model.IsEmailPublic);
paramCollection.AddWithValue("@IsDateOfBirthPublic", model.IsDateOfBirthPublic);
//start of Language
if (model.LanguageProficiencyKeys != null)
{
SqlParameter plang = new SqlParameter("@LanguageProficiencyKeys", SqlDbType.Structured);
if (model.LanguageProficiencyKeys.Any())
{
plang.Value = new NVarcharTable(model.LanguageProficiencyKeys);
}
paramCollection.Add(plang);
}
//end of Language
//start of Skill
DataTable SkillIdArray = new DataTable();
SkillIdArray.Columns.Add("SkillIds", typeof(Int32));
if (model.SkillIds != null)
{
for (int i = 0; i < model.SkillIds.Count; i++)
{
SkillIdArray.Rows.Add(model.SkillIds[i]);
}
}
SqlParameter SkillIdTable = new SqlParameter();
SkillIdTable.ParameterName = "@PersonSkillIds";
SkillIdTable.SqlDbType = System.Data.SqlDbType.Structured;
SkillIdTable.Value = SkillIdArray;
paramCollection.Add(SkillIdTable);
//end of Skill //
//Start of Base//
DataTable MilitaryBaseIdArray = new DataTable();
MilitaryBaseIdArray.Columns.Add("MilitaryBaseId", typeof(Int32));
if (model.MilitaryBaseIds != null)
{
for (int i = 0; i < model.MilitaryBaseIds.Count; i++)
{
MilitaryBaseIdArray.Rows.Add(model.MilitaryBaseIds[i]);
}
}
SqlParameter MilitaryBaseIdTable = new SqlParameter();
MilitaryBaseIdTable.ParameterName = "@PersonMilitaryBaseIds";
MilitaryBaseIdTable.SqlDbType = System.Data.SqlDbType.Structured;
MilitaryBaseIdTable.Value = MilitaryBaseIdArray;
paramCollection.Add(MilitaryBaseIdTable);
//End of Base//
//Start of Notifications//
DataTable PersonNotificationPreferenceArray = new DataTable();
PersonNotificationPreferenceArray.Columns.Add("PersonId", typeof(Int32));
PersonNotificationPreferenceArray.Columns.Add("NotificationEventId", typeof(Int32));
PersonNotificationPreferenceArray.Columns.Add("SendEmail", typeof(bool));
PersonNotificationPreferenceArray.Columns.Add("SendText", typeof(bool));
if (model.Preferences != null)
{
for (int i = 0; i < model.Preferences.Length; i++)
{
DataRow dr = PersonNotificationPreferenceArray.NewRow();
dr["PersonId"] = model.Preferences[i].PersonId;
dr["NotificationEventId"] = model.Preferences[i].NotificationEventId;
dr["SendEmail"] = model.Preferences[i].SendEmail;
dr["SendText"] = model.Preferences[i].SendText;
PersonNotificationPreferenceArray.Rows.Add(dr);
}
}
SqlParameter NotificationEventTable = new SqlParameter();
NotificationEventTable.ParameterName = "@PersonNotificationPreferences";
NotificationEventTable.SqlDbType = System.Data.SqlDbType.Structured;
NotificationEventTable.Value = PersonNotificationPreferenceArray;
paramCollection.Add(NotificationEventTable);
}
