public async Task <IActionResult> Update([FromBody] ProviderUpdateModel model)
{
if (!ModelState.IsValid)
{
return(BadModelResponse(ModelState));
}
return(Ok(await _providerManager.Update(model)));
}
public async Task <IActionResult> Update([FromBody] ProviderUpdateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Json(await _managerProvider.Update(model)));
}
/// <summary>
/// Create new provider
/// </summary>
/// <param name="model">new provider model</param>
/// <returns></returns>
public async Task <IdNameModel> Create(ProviderUpdateModel model)
{
if (model == null)
{
throw new ModelDamagedException(nameof(model), "can not be empty");
}
var user = await GetCurrentUser();
if (!(await _appUserManager.IsInRoleAsync(user, "MANAGER")) && !(await _appUserManager.IsInRoleAsync(user, "ADMIN")))
{
throw new NotEnoughRightsException();
}
if (string.IsNullOrWhiteSpace(model.Slug))
{
throw new ModelDamagedException(nameof(model.Slug), "can not be empty");
}
model.Slug = model.Slug.ToLower();
if (string.IsNullOrWhiteSpace(model.Category))
{
throw new ModelDamagedException(nameof(model.Category), "can not be empty");
}
if (model.Translations == null || !model.Translations.Any())
{
throw new ModelDamagedException(nameof(model.Translations), "can not be null or empty");
}
var isSlugExists = (await _providerRepository.Count(x => x.Slug == model.Slug && x.State == MREntityState.Active)) > 0;
if (isSlugExists)
{
throw new MRSystemException($"Provider with slug {model.Slug} already exists");
}
var category = await _providerCategoryRepository.GetFirst(x => x.Slug == model.Category);
if (category == null)
{
throw new EntityNotFoundException(model.Category, typeof(ProviderCategory));
}
var entity = _mapper.Map <Provider>(model);
entity.Owner = _mapper.Map <ProviderOwner>(user);
entity.Category = new ProviderProviderCategory
{
CategoryId = category.Id,
Slug = category.Slug
};
entity.Tags = new List <ProviderProviderTag>();
entity.Workers = new List <ProviderWorker>
{
new ProviderWorker
{
Roles = new List <ProviderWorkerRole>
{
ProviderWorkerRole.ANALYTICS,
ProviderWorkerRole.DEVELOPER,
ProviderWorkerRole.MANAGER,
ProviderWorkerRole.OWNER,
ProviderWorkerRole.USER_MANAGER
},
UserEmail = _userEmail,
UserId = _userId
}
};
// set avatar
if (entity.Avatar != null)
{
var image = await _imageOriginBucket.MoveFrom(_imageTmpBucket.BucketFullPath, model.Avatar.Key);
if (image != null && image.IsSuccess)
{
entity.Avatar.Url = image.Url;
}
}
// set background
if (entity.Background != null)
{
var image = await _imageOriginBucket.MoveFrom(_imageTmpBucket.BucketFullPath, model.Background.Key);
if (image != null && image.IsSuccess)
{
entity.Background.Url = image.Url;
}
}
var result = await _providerRepository.Insert(entity);
return(new IdNameModel
{
Id = result.Id,
Name = result.Name
});
}
/// <summary>
/// Updates provider model
/// </summary>
/// <param name="model">Provider to update</param>
/// <returns>Provider updpate model</returns>
public async Task <ProviderUpdateModel> Update(ProviderUpdateModel model)
{
if (model == null)
{
throw new BadRequestException();
}
var user = await GetCurrentUser();
if (!(await _appUserManager.IsInRoleAsync(user, "MANAGER")) && !(await _appUserManager.IsInRoleAsync(user, "ADMIN")))
{
throw new NotEnoughRightsException();
}
if (string.IsNullOrWhiteSpace(model.Slug))
{
throw new ModelDamagedException(nameof(model.Slug), "can not be null");
}
model.Slug = model.Slug.ToLower();
if (string.IsNullOrWhiteSpace(model.Category))
{
throw new ModelDamagedException(nameof(model.Category), "can not be null");
}
if (model.Translations == null || !model.Translations.Any())
{
throw new ModelDamagedException(nameof(model.Translations), "can not be null or empty");
}
if (model.Translations.Count(x => x.IsDefault) != 1)
{
throw new ModelDamagedException(nameof(model.Translations), "default is required");
}
var entity = await _providerRepository.Get(model.Id);
if (entity == null)
{
throw new EntityNotFoundException(model.Id, typeof(Provider));
}
if (entity.Owner.Id != (await GetCurrentUser()).Id)
{
throw new AccessDeniedException(model.Id, typeof(Provider));
}
var category = await _providerCategoryRepository.GetFirst(x => x.Slug == model.Category);
if (category == null)
{
throw new EntityNotFoundException(model.Category, typeof(ProviderCategory));
}
var newEntity = _mapper.Map <Provider>(model);
newEntity.Owner = entity.Owner;
newEntity.Category = new ProviderProviderCategory
{
CategoryId = category.Id,
Slug = category.Slug
};
bool removeAvatar = false;
bool removeBackground = false;
if (newEntity.Avatar.Key != entity.Avatar.Key)
{
var aMoveResponse = await _imageOriginBucket.MoveFrom(_imageTmpBucket.BucketFullPath, newEntity.Avatar.Key);
if (!aMoveResponse.IsSuccess)
{
throw new MRSystemException("Can not transfer image");
}
newEntity.Avatar.Url = aMoveResponse.Url;
removeAvatar = true;
}
if (newEntity.Background.Key != entity.Background.Key)
{
var bMoveResponse = await _imageOriginBucket.MoveFrom(_imageTmpBucket.BucketFullPath, newEntity.Avatar.Key);
if (!bMoveResponse.IsSuccess)
{
throw new MRSystemException("Can not transfer image");
}
newEntity.Background.Key = bMoveResponse.Key;
removeBackground = true;
}
if (removeAvatar)
{
await _imageOriginBucket.Delete(entity.Avatar.Key);
await _imageTmpBucket.Delete(newEntity.Avatar.Key);
}
if (removeBackground)
{
await _imageOriginBucket.Delete(entity.Background.Key);
await _imageTmpBucket.Delete(newEntity.Background.Key);
}
if (newEntity.Workers == null)
{
newEntity.Workers = new List <ProviderWorker>();
}
var replaceResponse = await _providerRepository.Replace(newEntity);
if (replaceResponse == null)
{
throw new MRSystemException();
}
return(_mapper.Map <ProviderUpdateModel>(newEntity));
}
public async Task <ProviderUpdateModel> Update(ProviderUpdateModel model)
{
if (model == null)
{
throw new MRException <ProviderUpdateModel>((int)ExceptionCode.BAD_REQUEST);
}
if (model.Name?.SelectTranslation(null) == null || model.Description?.SelectTranslation(null) == null)
{
throw new MRException <ProviderUpdateModel>((int)ExceptionCode.BAD_MODEL, "Default translations not found");
}
model.Slug = model.Slug.ToLowerInvariant().Replace(" ", "_");
var existsWithSlug = await _repositoryProvider.GetFirst(x => x.Slug == model.Slug && x.State == MREntityState.Active);
if (existsWithSlug != null)
{
if (string.IsNullOrWhiteSpace(model.Id) || existsWithSlug.Id != model.Id)
{
throw new MRException <ProviderUpdateModel>((int)ExceptionCode.BAD_MODEL, "Provider with this slug already exists");
}
}
Provider entity = null;
List <string> imagesToDelete = new List <string>();
if (string.IsNullOrWhiteSpace(model.Id))
{
entity = _mapper.Map <Provider>(model);
entity.CreateTime = DateTime.UtcNow;
if (model.Categories == null)
{
entity.Categories = new List <ProviderCategory>();
}
else
{
var dbCategories = (await _repositoryCategory
.GetIn(x => x.Id, model.Categories))
.Where(x => x.State == MREntityState.Active);
entity.Categories = _mapper.Map <List <ProviderCategory> >(dbCategories);
}
// set images
if (entity.Avatar != null && !string.IsNullOrWhiteSpace(entity.Avatar.Key))
{
imagesToDelete.Add(entity.Avatar.Key);
entity.Avatar = await CopyToRBucket(entity.Avatar.Key);
}
if (entity.Background != null && !string.IsNullOrWhiteSpace(entity.Background.Key))
{
imagesToDelete.Add(entity.Background.Key);
entity.Background = await CopyToRBucket(entity.Background.Key);
}
entity.Users = new List <ProviderUser>
{
new ProviderUser
{
CreatedBy = _userId,
CreateTime = DateTime.UtcNow,
Roles = new List <ProviderUserRole>
{
ProviderUserRole.OWNER
},
UserEmail = _userEmail,
UserId = _userId
}
};
try
{
entity = await _repositoryProvider.Insert(entity);
}
catch (Exception ex)
{
var e = ex;
}
}
else
{
entity = await _repositoryProvider.GetFirst(x => x.Id == model.Id && x.State == MREntityState.Active);
if (entity == null)
{
throw _eNotFound <ProviderUpdateModel>("Provider not found");
}
var oldAvatar = entity.Avatar;
var oldBackground = entity.Background;
_mapper.Map(model, entity);
if (model.Categories == null)
{
entity.Categories = new List <ProviderCategory>();
}
else
{
var dbCategories = (await _repositoryCategory
.GetIn(x => x.Id, model.Categories))
.Where(x => x.State == MREntityState.Active);
entity.Categories = _mapper.Map <List <ProviderCategory> >(dbCategories);
}
imagesToDelete.Add(await UpdateEntityImage(oldAvatar, entity.Avatar));
imagesToDelete.Add(await UpdateEntityImage(oldBackground, entity.Background));
imagesToDelete = imagesToDelete.Where(x => x != null).ToList();
entity.UpdateTime = DateTime.UtcNow;
}
ProviderUpdateModel result = null;
try
{
result = _mapper.Map <ProviderUpdateModel>(entity);
}
catch (Exception ex)
{
var e = ex;
}
if (imagesToDelete != null && imagesToDelete.Any())
{
foreach (var imageToDelete in imagesToDelete)
{
try
{
await _connectorBucketImageD.Delete(imageToDelete);
}
catch (Exception ex)
{
try
{
await _connectorBucketImageR.Delete(imageToDelete);
}
catch (Exception eex) { }
}
}
}
return(result);
}
