private void SetErrorHeaders(UsrDataShell usrDatas)
{
if (usrDatas.Error != null)
{
Response.Headers.Add("error", usrDatas.Error);
}
}
private UsrDataShell PrepareMultipartRequest()
{
UsrDataShell result = new UsrDataShell();
string queryType = Request.QueryString.Value;
if (queryType.StartsWith("?_put=") || queryType.StartsWith("?_post="))
{
string data = Request.Form.Where(x => x.Key == "JSON").Select(x => x.Value.ToString()).FirstOrDefault();
if (data != null)
{
switch (queryType.Replace("?_put=", "").Replace("?_post=", ""))
{
case ("skill"): {
try {
result.UsrData_ = JsonConvert.DeserializeObject <UsrSkill>(data);
result.EntityType = "skill";
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail deserialize Skill");
result.Error = "Fail deserialize Skill";
}
break;
}
case ("main"): {
try {
result.UsrData_ = JsonConvert.DeserializeObject <UsrMain>(data);
result.EntityType = "main";
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail deserialize Main info");
result.Error = "Fail deserialize Main info";
}
break;
}
default: {
result.Error = "Not found entity! Check query param";
break;
}
}
}
if (Request.Form.Files.Count > 0)
{
result.File = Request.Form.Files[0];
}
}
else
{
result.Error = "Wrong put/post query params";
}
return(result);
}
public async Task <IActionResult> Get()
{
UsrDataShell result = await _dbOperations.GetAsync(Request.QueryString.Value);
if (result.Error == null)
{
return(Ok(result.UsrDatas));
}
SetErrorHeaders(result);
return(BadRequest(result));
}
public async Task <IActionResult> Auth(UsrAdmin user)
{
UsrDataShell result = await _userAuthentication.AuthenticationAsync(user);
if (result.Error == null)
{
return(Ok(result.UsrData_));
}
SetErrorHeaders(result);
return(BadRequest());
}
public async Task <UsrDataShell> DelAsync(string queryParams, int id)
{
UsrDataShell result = new UsrDataShell();
if (queryParams.StartsWith("?_del="))
{
try
{
switch (queryParams.Replace("?_del=", ""))
{
case ("educations"): {;
result = await DataChangeAsync <UsrEducation>(await _resumeContext.UsrEducations.Where(educations => educations.UsrEducationId == id).FirstOrDefaultAsync(), EntityState.Deleted);
break; }
case ("experiences"): {
result = await DataChangeAsync <UsrExperience>(await _resumeContext.UsrExperiences.Where(experiences => experiences.UsrExperienceId == id).FirstOrDefaultAsync(), EntityState.Deleted);
break;
}
case ("skills"): {
_fileOperations.DeleteOldFile <UsrSkill>(
"X",
await SelectNoTrackingListAsync <UsrSkill>(),
id);
result = await DataChangeAsync <UsrSkill>(await _resumeContext.UsrSkills.Where(skills => skills.UsrSkillId == id).FirstOrDefaultAsync(), EntityState.Deleted);
break;
}
default: {
result.Error = "Not found entity! Check del query param"; break;
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail get data of DB");
result.Error = "Fail get data of DB";
}
}
else
{
result.Error = "Wrong del query params";
}
return(result);
}
public async Task <UsrDataShell> SendEmailAsync(UsrEmail usrEmail)
{
UsrDataShell result = new UsrDataShell();
string error = EmailInitializing();
if (error != null)
{
result.Error = error;
return(result);
}
error = await EmailSendAsync(usrEmail);
if (error != null)
{
result.Error = error;
}
return(result);
}
public async Task <IActionResult> EmailMessage(UsrEmail usrEmail)
{
var validateErrors = usrEmail.Validate();
if (validateErrors == null)
{
UsrDataShell result = await _emailOperations.SendEmailAsync(usrEmail);
if (result.Error == null)
{
return(Ok());
}
SetErrorHeaders(result);
}
else
{
Response.Headers.Add("error", validateErrors);
}
return(BadRequest());
}
public async Task <UsrDataShell> AuthenticationAsync(UsrAdmin user)
{
UsrDataShell result = new UsrDataShell();
var hashPassword = await _dbOperations.GetUserHashPasswordAsync(user.Login);
if (hashPassword == null)
{
result.Error = "User not found";
return(result);
}
if (hashPassword == "FAIL!")
{
result.Error = "Fail get data of DB";
return(result);
}
if (GetHashString(user.Password) != hashPassword)
{
result.Error = "Password incorrect";
return(result);
}
DateTime tokenDateOfDeath = DateTime.Now.AddHours(GetTokenLifetime());
bool saveToken = await _dbOperations.SetTokenDateOfDeathAsync(user.Login, tokenDateOfDeath);
if (!saveToken)
{
result.Error = "Fail set data of DB";
return(result);
}
Token token = new Token(user.Login, tokenDateOfDeath.ToString(), user.Login + hashPassword);
result.UsrData_ = new UsrAdmin()
{
TokenDateOfDeath = tokenDateOfDeath, Token = token.GetToken()
};
return(result);
}
public async Task <UsrDataShell> GetAsync(string queryParams)
{
UsrDataShell result = new UsrDataShell();
if (queryParams.StartsWith("?_get="))
{
try
{
switch (queryParams.Replace("?_get=", ""))
{
case ("main"): { result.UsrDatas = await _resumeContext.UsrMains.ToListAsync(); break; }
case ("contact"): { result.UsrDatas = await _resumeContext.UsrContacts.ToListAsync(); break; }
case ("about"): { result.UsrDatas = await _resumeContext.UsrAbouts.ToListAsync(); break; }
case ("educations"): { result.UsrDatas = await _resumeContext.UsrEducations.OrderBy(data => data.NumberInTurn).ToListAsync(); break; }
case ("experiences"): { result.UsrDatas = await _resumeContext.UsrExperiences.OrderBy(data => data.NumberInTurn).ToListAsync(); break; }
case ("skills"): { result.UsrDatas = await _resumeContext.UsrSkills.OrderBy(data => data.NumberInTurn).ToListAsync(); break; }
default: { result.Error = "Not found entity! Check get query param"; break; }
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail get data of DB");
result.Error = "Fail get data of DB";
}
}
else
{
result.Error = "Wrong get query params";
}
return(result);
}
public async Task <UsrDataShell> DataChangeAsync <TEntity>(TEntity usrData, EntityState entityState = EntityState.Modified) where TEntity : class
{
UsrDataShell result = new UsrDataShell();
try{
_resumeContext.Entry <TEntity>(usrData).State = entityState;
int updated = await _resumeContext.SaveChangesAsync();
if (updated == 1)
{
return(result);
}
else
{
result.Error = $"Fail {entityState.ToString()} data";
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail set data of DB");
result.Error = "Fail set data of DB";
}
return(result);
}
public async Task <IActionResult> PostMultipart()
{
UsrDataShell preResult = PrepareMultipartRequest();
UsrDataShell result = new UsrDataShell();
if (preResult.Error == null)
{
string pathForDB = await _fileOperations.SaveFile(preResult.File);
if (pathForDB != "FAIL!")
{
string validateErrors = "";
preResult.UsrData_.SavePathToImg(pathForDB);
switch (preResult.EntityType)
{
case ("skill"): {
validateErrors = (preResult.UsrData_ as UsrSkill).Validate();
if (validateErrors == null)
{
result = await _dbOperations.DataChangeAsync <UsrSkill>(preResult.UsrData_ as UsrSkill, EntityState.Added);
}
else
{
result.Error = validateErrors;
}
break;
}
case ("main"): {
validateErrors = (preResult.UsrData_ as UsrMain).Validate();
if (validateErrors == null)
{
result = await _dbOperations.DataChangeAsync <UsrMain>(preResult.UsrData_ as UsrMain, EntityState.Added);
}
else
{
result.Error = validateErrors;
}
break;
}
default: {
result.Error = "Not found entity! Check query param";
break;
}
}
if (result.Error == null)
{
return(Ok(preResult.UsrData_));
}
else
{
SetErrorHeaders(result);
}
}
else
{
preResult.Error = pathForDB;
}
}
SetErrorHeaders(preResult);
return(BadRequest());
}
public async Task <IActionResult> PutMultipart()
{
UsrDataShell preResult = PrepareMultipartRequest();
UsrDataShell result = new UsrDataShell();
if (preResult.Error == null)
{
string pathForDB = await _fileOperations.SaveFile(preResult.File);
if (pathForDB != "FAIL!")
{
string validateErrors = "";
preResult.UsrData_.SavePathToImg(pathForDB);
switch (preResult.EntityType)
{
case ("skill"): {
UsrSkill updateUsrSkill = (preResult.UsrData_ as UsrSkill);
validateErrors = updateUsrSkill?.Validate();
if (validateErrors == null)
{
_fileOperations.DeleteOldFile <UsrSkill>(
pathForDB,
await _dbOperations.SelectNoTrackingListAsync <UsrSkill>(),
updateUsrSkill.GetKey());
result = await _dbOperations.DataChangeAsync <UsrSkill>(updateUsrSkill);
}
else
{
result.Error = validateErrors;
}
break;
}
case ("main"): {
UsrMain updateUsrMain = (preResult.UsrData_ as UsrMain);
validateErrors = updateUsrMain?.Validate();
if (validateErrors == null)
{
_fileOperations.DeleteOldFile <UsrMain>(
pathForDB,
await _dbOperations.SelectNoTrackingListAsync <UsrMain>(),
updateUsrMain.GetKey());
result = await _dbOperations.DataChangeAsync <UsrMain>(updateUsrMain);
}
else
{
result.Error = validateErrors;
}
break;
}
default: {
result.Error = "Not found entity! Check query param";
break;
}
}
if (result.Error == null)
{
return(Ok(preResult.UsrData_));
}
else
{
SetErrorHeaders(result);
}
}
else
{
preResult.Error = pathForDB;
}
}
SetErrorHeaders(preResult);
return(BadRequest());
}
