public async Task <IActionResult> PutAssign(Guid id, Assign assign)
{
if (id != assign.Id)
{
return(BadRequest());
}
_context.Entry(assign).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AssignExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <string> SaveAvatar(IFormFile file, long userID)
{
var fileName = Guid.NewGuid().ToString();
var filePath = Path.Join("images", fileName);
var uriPath = $"images/{fileName}";
using (var stream = File.Create(filePath))
{
await file.CopyToAsync(stream);
}
var user = await _context.Users.FindAsync(userID);
var oldAvatar = user.AvatarURI;
user.AvatarURI = uriPath;
_context.Entry(user).State = EntityState.Modified;
await _context.SaveChangesAsync();
if (oldAvatar != null)
{
RemoveImage(oldAvatar);
}
return(uriPath);
}
public async Task <IActionResult> PutPlaceType(long id, PlaceTypeRequest placeTypeDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var placeType = await _context.PlaceTypes.FindAsync(id);
_mapper.Map(placeTypeDTO, placeType);
_context.Entry(placeType).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlaceTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEmployee(Guid id, Employee employee)
{
if (id != employee.Id)
{
return(BadRequest());
}
_context.Entry(employee).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Subject> Create(Subject entity)
{
if (entity == null)
{
throw new Exception("Entity cannot be null");
}
var result = await _dbContext.Set <Subject>().AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(result.Entity);
}
public async Task <IActionResult> Post([FromBody] Model.Feedback feedback)
{
_feedbackContext.Feedback.Add(feedback);
await _feedbackContext.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created));
}
public async Task <ActionResult <Feedback> > PostFeedback(Feedback feedback)
{
// _context.Feedback.Add(feedback);
// Customer ID
int IdC = 0;
_context.SaveChanges();
if (null != _context.Customers.FirstOrDefault(x => x.PhoneNumber == feedback.PhoneNumber &&
x.Mail == feedback.Mail && 0 < x.ID))
{
IdC = _context.Customers.FirstOrDefault(x => x.PhoneNumber == feedback.PhoneNumber &&
x.Mail == feedback.Mail && 0 < x.ID).ID;
}
else
{
_context.Customers.Add(new Customer(feedback.Surname, feedback.Mail, feedback.PhoneNumber));
_context.SaveChanges();
var Cont = _context.Customers.FirstOrDefault(x => x.ID == _context.Customers.Max(p => p.ID));
IdC = Cont.ID;
}
// Theme ID
int IdT = _context.ThemeList.FirstOrDefault(x => x.ThemeName == feedback.Theme).ID;
_context.Messages.Add(new Message(feedback.Message, IdC, IdT));
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFeedback", new { id = feedback.ID }, feedback));
}
/// <summary>
/// Удаляет отзыв с заданным id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task Delete(Guid id)
{
using (var db = new FeedbackContext())
{
var feedback = await db.Feedbacks.FindAsync(id);
db.Feedbacks.Remove(feedback);
await db.SaveChangesAsync();
}
}
/// <summary>
/// Асинхронно изменяет текст заданного отзыва
/// </summary>
/// <param name="id">id отзыва</param>
/// <param name="text">Новый текст</param>
/// <returns></returns>
public async Task Update(Guid id, string text)
{
using (var db = new FeedbackContext())
{
var feedback = await db.Feedbacks.FindAsync(id);
feedback.Text = text;
db.Entry(feedback).State = EntityState.Modified;
await db.SaveChangesAsync();
}
}
public async Task <User> Register(User user, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(user);
}
/// <summary>
/// Добавляет в базу новую категорию с указанными данными
/// </summary>
/// <param name="name">Имя категории</param>
/// <param name="isActive">Активность категории</param>
/// <returns></returns>
public async Task Insert(string name, bool isActive)
{
using (var db = new FeedbackContext())
{
var category = new Category
{
Name = name,
IsActive = isActive
};
db.Categories.Add(category);
await db.SaveChangesAsync();
}
}
/// <summary>
/// Удалить категорию, имеющую указанное имя
/// </summary>
/// <param name="name">Имя категории</param>
/// <returns></returns>
public async Task Delete(string name)
{
using (var db = new FeedbackContext())
{
var category = await db.Categories.FirstOrDefaultAsync(t => t.Name == name);
if (category == null)
{
return;
}
category.Name = name;
await db.SaveChangesAsync();
}
}
/// <summary>
/// Добавляет в базу новый отзыв с указанными данными
/// </summary>
/// <param name="id">id нового отзыва</param>
/// <param name="categoryId">id категории отзыва</param>
/// <param name="text">Текст отзыва</param>
/// <param name="userName">Имя автора</param>
/// <param name="files">Список путей к прикрепленным файлам</param>
/// <returns></returns>
public async Task Insert(Guid id, Guid categoryId, string text, string userName = "", IEnumerable <string> files = null)
{
using (var db = new FeedbackContext())
{
var feedback = new Feedback(id, categoryId, text, DateTime.Now, userName);
if (files != null)
{
feedback.AttachedFiles = files.Select(file => new FeedbackFile(file)).ToList();
}
db.Feedbacks.Add(feedback);
await db.SaveChangesAsync();
}
}
public async Task <int> SaveAsync()
{
foreach (var entry in _context.ChangeTracker.Entries()
.Where(e => e.State == EntityState.Added))
{
if (!(entry.Entity is BaseEntity entity))
{
continue;
}
entity.CreatedDate = DateTimeOffset.UtcNow;
}
return(await _context.SaveChangesAsync());
}
/// <summary>
/// Удаляет категорию с указанным id
/// </summary>
/// <param name="id">id категории</param>
/// <returns></returns>
public async Task Delete(Guid id)
{
using (var db = new FeedbackContext())
{
var category = await db.Categories.FindAsync(id);
if (category == null)
{
return;
}
db.Categories.Remove(category);
await db.SaveChangesAsync();
}
}
/// <summary>
/// Устанавливает значение активности категории
/// </summary>
/// <param name="id">id категории</param>
/// <param name="active">Активность</param>
/// <returns></returns>
public async Task SetActive(Guid id, bool active)
{
using (var db = new FeedbackContext())
{
var category = await db.Categories.FindAsync(id);
if (category == null)
{
return;
}
category.IsActive = active;
await db.SaveChangesAsync();
}
}
public async Task <bool> SaveFeedback(VmSaveFeedback param)
{
var applicationDetail = await feedbackContext.Applications.FirstOrDefaultAsync(x => x.Enabled && x.ApplicationPublicKey == param.ApplicationKey);
Model.Database.Feedback feedbackModel = new Model.Database.Feedback();
feedbackModel.DeviceKey = param.DeviceKey;
feedbackModel.Message = param.Message.Trim();
feedbackModel.ApplicationId = applicationDetail.Id;
feedbackModel.DeviceKey = param.DeviceKey;
await feedbackContext.Feedback.AddAsync(feedbackModel);
var resultCount = await feedbackContext.SaveChangesAsync();
//Send Mail?
if (resultCount > 0 && Convert.ToBoolean(config["NewFeedbackAfterSendMail"]))
{
await myEmailSender.SendEmailAsync(config["NewFeedbackAfterSendMailAdress"], "Feedback", $"Feedback Application : {applicationDetail.ApplicationName} | \n Message : {param.Message}");
}
return(resultCount > 0);
}
public async Task <IActionResult> PutUser(long id, UserFullUpdateRequest userDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (userDTO.Role != Role.Admin && userDTO.Role != Role.User)
{
return(BadRequest("Invalid role."));
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.ID == id);
if (user == null)
{
return(NotFound("User not found."));
}
_mapper.Map(userDTO, user);
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task AddUserAsync(User user)
{
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
}
public async Task <IActionResult> PutPlace(long id, PlaceRequest placeRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
/*
* var place = _mapper.Map<Place>(placeDTO);
* place.PlaceType = await _context.PlaceTypes.FirstOrDefaultAsync(pt => pt.Name == placeDTO.Type);
* place.PlaceTypeID = place.PlaceType?.ID ?? 0;
*
* if (place.PlaceType == null)
* {
* return BadRequest();
* }
*
*/
if (!IsAuthorized(id))
{
return(Unauthorized());
}
var place = await _context.Places
.Include(p => p.OpeningTimes)
.Include(p => p.PlaceType)
.FirstOrDefaultAsync(p => p.ID == id);
_mapper.Map(placeRequest, place);
_context.Entry(place).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlaceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}