public async Task <EntityOperationResult <TBase> > CreateItemAsync(TDto basketCreateDto)
{
string errors = CheckAndGetErrors(basketCreateDto);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <TBase> .Failure().AddError(errors));
}
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
TBase value = _mapper.Map <TBase>(basketCreateDto);
var entity = await unitOfWork.GetRepository <TBase>().AddAsync(value);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <User> > Authenticate(string username, string password)
{
var result = new EntityOperationResult <User>();
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
result.AddError("Login fail", "Name or Password are empty");
return(result);
}
var user = await _context.Users.FirstOrDefaultAsync(x => x.Name == username);
if (user == null)
{
result.AddError("User inexistent", "User is nor registered");
return(result);
}
if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
{
result.AddError("User invalid", "User password invalid");
return(result);
}
// authentication successful
return(new EntityOperationResult <User>(user));
}
public async Task <EntityOperationResult <TBase> > DeleteItemAsync(int id)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
TBase value = unitOfWork.GetRepository <TBase>().GetById(id);
if (value == null)
{
return(EntityOperationResult <TBase> .Failure().AddError("Не найдена запись"));
}
string error = CkeckBefforDelet(value);
if (!string.IsNullOrEmpty(error))
{
return(EntityOperationResult <TBase> .Failure().AddError(error));
}
unitOfWork.GetRepository <TBase>().Delete(value);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(value));
}
catch (Exception ex)
{
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
private EntityOperationResult UpdateInternal(EntityUpdate update)
{
if (!RunInspection(update))
{
return(EntityOperationResult.FailResult(new EntityOperationError("Insufficient rights to perform this operation.", EntityOperationError.ACCESS_VIOLATION)));
}
EntityOperationContext ctx = new EntityOperationContext();
this.AppyLogicBefore(update, ctx);
var entity = update.ToEntity();
EntityOperationResult result = null;
bool created = false;
try
{
if (update.Id.HasValue)
{
if (update.PropertyUpdates.Count > 0)
{
_repository.Update(entity);
}
}
else
{
update.Id = _repository.Create(entity);
created = true;
}
//Order by operation - process detach first
foreach (var relUpdate in update.RelationUpdates.OrderByDescending(ru => ru.Operation))
{
if (relUpdate.Operation == RelationOperation.Attach)
{
_repository.Attach(entity, relUpdate.ToRelation());
}
else if (relUpdate.Operation == RelationOperation.Detach)
{
_repository.Detach(entity, relUpdate.ToRelation());
}
else if (relUpdate.PropertyUpdates.Count > 0)
{
_repository.UpdateRelation(entity, relUpdate.ToRelation());
}
}
result = EntityOperationResult.SuccessResult();
if (created)
{
result.Data.Add("Created", update.Id.Value);
}
}
catch (UniqueRuleViolationException rex)
{
result = EntityOperationResult.FailResult(new EntityOperationError(rex.Message, EntityOperationError.UNIQUE_RULE_VIOLATION));
}
this.AppyLogicAfter(update, ctx, result);
return(result);
}
public async Task <EntityOperationResult <TBase> > DeleteItemAsync(List <int> idList)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
if (idList == null || idList.Count == 0)
{
return(EntityOperationResult <TBase> .Failure().AddError("Не задан лист с id"));
}
List <TBase> listVal = await unitOfWork.GetRepository <TBase>().GetAllOfIdAsync(idList);
if (listVal == null || listVal.Count == 0)
{
return(EntityOperationResult <TBase> .Failure().AddError("Не найдена запись"));
}
string error = CkeckBefforDeleteList(listVal);
if (!string.IsNullOrEmpty(error))
{
return(EntityOperationResult <TBase> .Failure().AddError(error));
}
unitOfWork.GetRepository <TBase>().DeleteALot(listVal);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(listVal[0]));
}
catch (Exception ex)
{
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <TBase> > CreateItemAsync(TDto basketCreateDto)
{
// Валидацию модели можно сделать через атрибуты валидации, которые ты вешаешь на свойства класса.
// Взывать проверку на основе атрибутов можно своим кодом. Я уже такой писал:
// https://github.com/maximgorbatyuk/net-blank-app/blob/master/src/Utils/Validators/EntityValidator.cs
string errors = CheckAndGetErrors(basketCreateDto);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <TBase> .Failure().AddError(errors));
}
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
TBase value = _mapper.Map <TBase>(basketCreateDto);
var entity = await unitOfWork.GetRepository <TBase>().AddAsync(value);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(entity));
}
catch (Exception ex)
{
// Если ты хочешь использовать подход с классом-прокси EntityOperationResult,
// То я бы сохранял и передавал выше еще и сам объект ex, потому что в эксепшене важно не только месседж,
// но и стектрейс, и дополнительная инфа, и тип класса исключения.
// Но я бы отказался от такого прокси-класса и пробрасывал бы исключение наверх дальше, даже
// не отлавливая его здесь.
// Исключения ты отлавливаешь в одной точке - в созданной специально для этого middleware.
// а узнать, что это такое, ты можешь либо из нашего курса, либо на сайте metanit.com
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
public virtual async Task <EntityOperationResult <TDto> > CreateAsync(TDtoCreate createDto)
{
string errors = CheckBeforeModification(createDto);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <TDto> .Failure().AddError(errors));
}
try
{
TEntity value = mapper.Map <TEntity>(createDto);
var entity = await repositoryBase.AddAsync(value);
await repositoryBase.SaveAsync();
var dto = mapper.Map <TDto>(entity);
return(EntityOperationResult <TDto> .Success(dto));
}
catch (Exception ex)
{
return(EntityOperationResult <TDto> .Failure().AddError(ex.Message));
}
}
public async Task <EntityOperationResult <AgeCategory> > EditAsync(AgeCategoryDto editDto)
{
string errors = CheckBeforeModification(editDto, false);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <AgeCategory> .Failure().AddError(errors));
}
try
{
var value = await repositoryBaseId.GetByIdAsync(editDto.Id);
value.AgeBegin = editDto.AgeBegin;
value.AgeEnd = editDto.AgeEnd;
repositoryBaseId.Update(value);
await repositoryBaseId.SaveAsync();
return(EntityOperationResult <AgeCategory> .Success(value));
}
catch (Exception ex)
{
return(EntityOperationResult <AgeCategory> .Failure().AddError(ex.Message));
}
}
private EntityOperationResult <Project> Check(ProjectDto project)
{
if (project.Name == string.Empty)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указано наименование"));
}
if (project.ContractorCompany == string.Empty)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указано наименование компании-исполнителя"));
}
if (project.CustomerCompany == string.Empty)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указано наименование компании-заказчика"));
}
if (project.DateBegin == null || project.DateEnd == null)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указан период"));
}
if (project.SupervisorUser == null)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указаны руководитель проекта"));
}
return(null);
}
public async Task <EntityOperationResult <Language> > EditItemAsync(LanguageDto basketEditDto)
{
string errors = CheckAndGetErrors(basketEditDto, false);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <Language> .Failure().AddError(errors));
}
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
var language = unitOfWork.Language.GetById(basketEditDto.Id);
if (language == null)
{
return(EntityOperationResult <Language> .Failure().AddError("Не найдена запись"));
}
language.Name = basketEditDto.Name;
unitOfWork.Language.Update(language);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <Language> .Success(language));
}
catch (Exception ex)
{
return(EntityOperationResult <Language> .Failure().AddError(ex.Message));
}
}
}
public EntityOperationResult updateEmployeeRecord(EmployeeDTO emp)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = dbContext.employees.FirstOrDefault(x => x.id == emp.id);
if (dbObj != null)
{
dbObj.emp_name = emp.emp_name;
dbContext.SaveChanges();
ret.id = dbObj.id;
ret.isSuccess = true;
ret.message = "Successfully update";
}
else
{
ret.id = emp.id;
ret.isSuccess = false;
ret.message = "Record not found";
}
}
catch (Exception ex)
{
ret.id = 0;
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public async Task <EntityOperationResult <Dish> > DeleeteItemAsync(DishDeleteDto deleteDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
var dish = unitOfWork.Dish.GetById(deleteDto.Id);
unitOfWork.Dish.Delete(dish);
await unitOfWork.CompleteAsync();
if (dish.PictureName?.Length > 0)
{
FileService fileService = new FileService(null, path + "\\" + dish.PictureName,
string.Empty, dish.PictureFormat);
fileService.AddOrDelete(true);
}
return(EntityOperationResult <Dish> .Success(dish));
}
catch (Exception ex)
{
return(EntityOperationResult <Dish> .Failure().AddError(ex.Message));
}
}
}
public EntityOperationResult daleteTask(long taskid)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = dbContext.employeeTasks.FirstOrDefault(x => x.id == taskid);
if (dbObj != null)
{
dbContext.Remove(dbObj);
dbContext.SaveChanges();
ret.isSuccess = true;
ret.message = "Successfully delete";
}
else
{
ret.isSuccess = false;
ret.message = "Record not found plz try again";
}
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public EntityOperationResult saveEmployeeRecord(EmployeeDTO emp)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = new Employee();
dbObj.emp_name = emp.emp_name;
dbContext.employees.Add(dbObj);
dbContext.SaveChanges();
ret.id = dbObj.id;
ret.isSuccess = true;
ret.message = "Successfully Save";
}
catch (Exception ex)
{
ret.id = 0;
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public EntityOperationResult updaeTask(EmployeeTaskDTO empTask)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = dbContext.employeeTasks.FirstOrDefault(x => x.id == empTask.id);
if (dbObj != null)
{
dbObj.title = empTask.title;
dbObj.description = empTask.description;
dbObj.estimate = empTask.estimate;
dbObj.prioritylevel_id = empTask.prioritylevel_id;
dbObj.state_id = empTask.state_id;
dbContext.SaveChanges();
ret.id = dbObj.emp_id;
ret.isSuccess = true;
ret.message = "Successfully Save";
}
else
{
ret.isSuccess = false;
ret.message = "Record not found plz try again";
}
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public EntityOperationResult addTask(EmployeeTaskDTO empTask)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = new EmployeeTask();
dbObj.title = empTask.title;
dbObj.emp_id = empTask.emp_id;
dbObj.description = empTask.description;
dbObj.estimate = empTask.estimate;
dbObj.prioritylevel_id = empTask.prioritylevel_id;
dbObj.state_id = empTask.state_id;
dbContext.employeeTasks.Add(dbObj);
dbContext.SaveChanges();
ret.id = dbObj.emp_id;
ret.isSuccess = true;
ret.message = "Successfully Save";
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public async Task <EntityOperationResult <Author> > EditAsync(AuthorDto editDto)
{
string errors = CheckBeforeModification(editDto, false);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <Author> .Failure().AddError(errors));
}
try
{
var value = await repositoryBaseId.GetByIdAsync(editDto.Id);
value.FirstName = editDto.FirstName;
value.MiddleName = editDto.MiddleName;
value.SurName = editDto.SurName;
repositoryBaseId.Update(value);
await repositoryBaseId.SaveAsync();
return(EntityOperationResult <Author> .Success(value));
}
catch (Exception ex)
{
return(EntityOperationResult <Author> .Failure().AddError(ex.Message));
}
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
{
return;
}
}
public async Task <EntityOperationResult <Project> > DeleteItemAsync(ProjectDto projectDeleteDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var project = unitOfWork.Project.GetById(projectDeleteDto.Id);
if (project.ProjectUsers.Any(x => projectDeleteDto.ProjectTasks.Count > 0))
{
return(EntityOperationResult <Project>
.Failure()
.AddError($"Есть задания удалите сперва их"));
}
try
{
SetProjectIdToList(project.ProjectUsers, project.Id);
unitOfWork.Project.UpdateProjectUsers(null, project.ProjectUsers);
unitOfWork.Project.Delete(project);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <Project> .Success(project));
}
catch (Exception ex)
{
return(EntityOperationResult <Project> .Failure().AddError(ex.Message));
}
}
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (operation.IsEntity(Notification.ENTITY) &&
operation is EntityUpdate &&
context.Get <bool>(CTXKEY_CREATENOTIFICATION) &&
result.Success)
{
var update = operation as EntityUpdate;
var method = ReplyMethods.ByNotification;//default
if (update.ContainsProperty("Method"))
{
method = update.Get <ReplyMethods>("Method");
}
var recipientUpdate = update.GetRelationUpdate(User.ENTITY, Roles.Recipient);
var attachments = update.GetMultipleRelationUpdates(NbuLibrary.Core.Domain.File.ENTITY, Roles.Attachment);
if (attachments != null)
{
foreach (var att in attachments)
{
_fileService.GrantAccess(att.Id.Value, FileAccessType.Read, new User(recipientUpdate.Id.Value));
}
}
var recipientQuery = new EntityQuery2(User.ENTITY, recipientUpdate.Id.Value);
recipientQuery.AddProperty("Email");
var recipient = _repository.Read(recipientQuery);
var to = recipient.GetData <string>("Email");
var body = update.Get <string>("Body");
var subject = update.Get <string>("Subject");
}
}
public async Task <EntityOperationResult <Organization> > DeleeteItemAsync(OrganizationDeleteDto deleteDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
if (unitOfWork.Organization.IsHasDishesh(deleteDto.Id))
{
return(EntityOperationResult <Organization>
.Failure()
.AddError($"Кафе с именем {deleteDto.Name} имеет блюда"));
}
try
{
var organization = unitOfWork.Organization.GetById(deleteDto.Id);
FileService fileService = new FileService(null, path + "/Org/\\" + organization.PictureName,
string.Empty, organization.PictureFormat);
fileService.AddOrDelete(true);
unitOfWork.Organization.Delete(organization);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <Organization> .Success(organization));
}
catch (Exception ex)
{
return(EntityOperationResult <Organization> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <ProjectTask> > EditItemAsync(ProjectTaskDto projectTaskEditDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var result = Check(projectTaskEditDto);
if (result != null)
{
return(result);
}
var projectTask = unitOfWork.ProjectTask.GetById(projectTaskEditDto.Id);
try
{
projectTask.Name = projectTaskEditDto.Name;
projectTask.AuthorId = projectTaskEditDto.Author.Id;
projectTask.ExecutorId = projectTaskEditDto.Executor.Id;
projectTask.Status = (int)projectTaskEditDto.Status;
projectTask.ProjectId = projectTaskEditDto.Project.Id;
projectTask.Priority = projectTaskEditDto.Priority;
projectTask.Comment = projectTaskEditDto.Comment;
unitOfWork.ProjectTask.Update(projectTask);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <ProjectTask> .Success(projectTask));
}
catch (Exception ex)
{
return(EntityOperationResult <ProjectTask> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <Project> > EditItemAsync(ProjectDto projectEditDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var result = Check(projectEditDto);
if (result != null)
{
return(result);
}
var project = unitOfWork.Project.GetById(projectEditDto.Id);
for (int i = 0; i < projectEditDto.ProjectUsers.Count; i++)
{
if (projectEditDto.ProjectUsers[i].Status == ProjectUserStatus.New)
{
if (project.ProjectUsers.Count(x => x.UserId == projectEditDto.ProjectUsers[i].Id) > 0)
{
return(EntityOperationResult <Project>
.Failure()
.AddError($"Пользователь {projectEditDto.ProjectUsers[i].Name} уже есть в базе"));
}
}
}
try
{
GetProjectDtoToProject(projectEditDto, project);
unitOfWork.Project.Update(project);
await unitOfWork.CompleteAsync();
var projectUserList = Mapper.Map <List <ProjectUser> >(projectEditDto.ProjectUsers
.Where(x => x.Status == ProjectUserStatus.New)
.ToList());
SetProjectIdToList(projectUserList, project.Id);
List <int> deleteList = projectEditDto.ProjectUsers
.Where(x => x.Status == ProjectUserStatus.Delete)
.Select(x => x.Id).ToList();
var projectUserDeleteList = new List <ProjectUser>();
if (deleteList?.Count > 0)
{
projectUserDeleteList = project.ProjectUsers
.Where(y => deleteList.Any(x => x == y.Id)).ToList();
}
SetProjectIdToList(projectUserDeleteList, project.Id);
unitOfWork.Project.UpdateProjectUsers(projectUserList, projectUserDeleteList);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <Project> .Success(project));
}
catch (Exception ex)
{
return(EntityOperationResult <Project> .Failure().AddError(ex.Message));
}
}
}
private async Task <EntityOperationResult <CurrencyDto> > GetDataFromHtmlAsync(string htmlPage, DateTime date)
{
var result = new EntityOperationResult <CurrencyDto>();
var parser = new HtmlParser();
var document = parser.ParseDocument(htmlPage);
if (document.GetElementsByClassName("sinResultados").Any())
{
Logger.LogInformation("Creating Currency object with No Price.");
result.Entity = CreateCurrency(date, "0", ServiceSettings.CurrencyCode, "0");
return(result);
}
var titleValidation = document.GetElementsByTagName("tr").ElementAtOrDefault(1);
if (titleValidation == null)
{
await SendSlackNotification(htmlPage, date, CurrencyCodeEnum.Ars);
result.AddError("Html error", $"Error getting HTML, not exist currency USD. Check Date {date.ToUniversalTime().ToShortDateString()}.");
return(result);
}
var tableRows = document.QuerySelectorAll("table > tbody > tr");
var usdCurrency = GetCurrencyByDate(tableRows, date);
if (usdCurrency == null)
{
Logger.LogInformation("Creating Currency object with No Price.");
result.Entity = CreateCurrency(date, "0", ServiceSettings.CurrencyCode, "0");
return(result);
}
var columns = usdCurrency.GetElementsByTagName("td");
var buyColumn = columns.ElementAtOrDefault(1);
var saleColumn = columns.ElementAtOrDefault(2);
var dateColumn = columns.ElementAtOrDefault(3);
if (buyColumn != null && saleColumn != null && dateColumn != null)
{
Logger.LogInformation("Creating Currency object to returned to the client.");
result.Entity = CreateCurrency(date, saleColumn.InnerHtml, ServiceSettings.CurrencyCode, buyColumn.InnerHtml);
return(result);
}
await SendSlackNotification(htmlPage, date, CurrencyCodeEnum.Ars);
result.AddError("Error Bna", "Error getting currency, please check HTML.");
return(result);
}
public async Task <EntityOperationResult <T> > UpdateAsync(TDto dto)
{
try
{
T value = mapper.Map <T>(dto);
repositoryBase.Update(value);
return(EntityOperationResult <T> .Success(value));
}
catch (Exception ex)
{
return(EntityOperationResult <T> .Failure().AddError(ex.Message));
}
}
public override async Task <EntityOperationResult <AuthorDto> > GetByIdDeteilsAsync(Guid id)
{
try
{
var entity = await authorRepository.GetByIdAsync(id, GetOptionsForDeteils());
var dto = mapper.Map <AuthorDto>(entity);
return(EntityOperationResult <AuthorDto> .Success(dto));
}
catch (Exception ex)
{
return(EntityOperationResult <AuthorDto> .Failure().AddError(ex.Message));
}
}
public async Task <EntityOperationResult <Dish> > EditItemAsync(DishEditDto editDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
if (unitOfWork.Dish.IsExistByNAme(editDto.Id, editDto.Name, editDto.OrganizationId))
{
return(EntityOperationResult <Dish>
.Failure()
.AddError($"Блюдо с именем {editDto.Name} уже существует"));
}
if (editDto.Price <= 0)
{
return(EntityOperationResult <Dish>
.Failure()
.AddError("Цена не может быть меньше или равняться нулю"));
}
try
{
var dish = unitOfWork.Dish.GetById(editDto.Id);
string oldPictureFormat = dish.PictureFormat;
var fileService = new FileService(editDto.File, path + "\\" + dish.PictureName,
editDto.PictureName, dish.PictureFormat);
dish.Name = editDto.Name;
dish.Price = editDto.Price;
if (editDto.File?.Length > 0 && !editDto.IsPictureDelete)
{
dish.PictureFormat = fileService.GetTypeFile();
}
else if (editDto.IsPictureDelete)
{
dish.PictureFormat = string.Empty;
}
dish.Comment = editDto.Comment;
unitOfWork.Dish.Update(dish);
await unitOfWork.CompleteAsync();
fileService.AddOrDelete(editDto.IsPictureDelete);
return(EntityOperationResult <Dish> .Success(dish));
}
catch (Exception ex)
{
return(EntityOperationResult <Dish> .Failure().AddError(ex.Message));
}
}
}
public async Task GetCurrency_ShouldBeHttpStatusCodeBadRequest_WhenResponseReturnAnError()
{
//Arrange
var result = new EntityOperationResult <CurrencyDto>();
result.AddError("", "");
_testServer.CurrencyServiceMock.Setup(x => x.GetCurrencyByCurrencyCodeAndDate(
It.IsAny <DateTime>(),
It.IsAny <CurrencyCodeEnum>()))
.ReturnsAsync(result);
// Act
var response = await _client.GetAsync("conversion/Ars/01-02-2012");
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task GetCurrency_ShouldBeHttpStatusCodeBadRequest_WhenUrlDoesHaveInvalidCurrencyCode()
{
//Arrange
const string currencyCode = "Test";
var result = new EntityOperationResult <CurrencyDto>();
result.AddError("Currency code invalid", $"Currency code invalid: {currencyCode}");
_testServer.CurrencyServiceMock.Setup(x => x.GetCurrencyByCurrencyCodeAndDate(
It.IsAny <DateTime>(),
It.IsAny <CurrencyCodeEnum>()))
.ReturnsAsync(result);
// Act
var response = await _client.GetAsync("conversion/TEST/02-02-2020");
// Assert
Assert.False(response.IsSuccessStatusCode);
}
public async Task <EntityOperationResult <Dish> > CreateItemAsync(DishCreateDto createDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
if (unitOfWork.Dish.IsExistByNAme(createDto.Name, createDto.OrganizationId))
{
return(EntityOperationResult <Dish>
.Failure()
.AddError($"Блюдо с именем {createDto.Name} уже существует"));
}
if (createDto.Price <= 0)
{
return(EntityOperationResult <Dish>
.Failure()
.AddError("Цена не может быть меньше или равняться нулю"));
}
try
{
var dish = new Dish
{
Name = createDto.Name,
OrganizationId = createDto.OrganizationId,
Price = createDto.Price,
PictureName = System.Guid.NewGuid().ToString(),
Comment = createDto.Comment
};
var fileService = new FileService(createDto.File, path + "\\" +
dish.PictureName, createDto.PictureName);
dish.PictureFormat = fileService.GetTypeFile();
var entity = await unitOfWork.Dish.AddAsync(dish);
await unitOfWork.CompleteAsync();
fileService.Add();
return(EntityOperationResult <Dish> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <Dish> .Failure().AddError(ex.Message));
}
}
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
return;
if (operation.IsEntity(EntityConsts.Issue) && operation is EntityUpdate)
{
var update = operation as EntityUpdate;
if (context.Get<bool>(CTXKEY_SEND_ISSUE))
{
SendIssueToSubscribers(operation as EntityUpdate);
}
if (update.ContainsRelation(File.ENTITY, Roles.Content))
{
var filesAttached = update.GetMultipleRelationUpdates(File.ENTITY, Roles.Content).Where(fu => fu.Operation == RelationOperation.Attach);
if (filesAttached.Count() > 0)
{
var issue = update.ToEntity();
var q = new EntityQuery2(EntityConsts.Magazine);
q.WhereRelated(new RelationQuery(EntityConsts.Issue, Roles.Issue, issue.Id));
q.Include(User.ENTITY, Roles.Subscriber);
var mag = _repository.Read(q);
var subscribers = mag.GetManyRelations(User.ENTITY, Roles.Subscriber).Select(r => new User(r.Entity));
foreach (var subscriber in subscribers)
{
foreach (var fileUpdate in filesAttached)
{
if (!_fileService.HasAccess(subscriber, fileUpdate.Id.Value))
_fileService.GrantAccess(fileUpdate.Id.Value, FileAccessType.Read, subscriber);
}
}
}
}
}
else if (operation is EntityUpdate)
{
var update = operation as EntityUpdate;
if (update.IsEntity(User.ENTITY) && update.ContainsRelation(EntityConsts.Magazine, Roles.Subscriber))
{
var rus = update.GetMultipleRelationUpdates(EntityConsts.Magazine, Roles.Subscriber).Where(ru => ru.Operation == RelationOperation.Attach);
foreach (var ru in rus)
{
var q = new EntityQuery2(EntityConsts.Issue);
q.WhereRelated(new RelationQuery(EntityConsts.Magazine, Roles.Issue, ru.Id.Value));
q.Include(File.ENTITY, Roles.Content);
var issues = _repository.Search(q);
foreach (var issue in issues)
{
//The user cannot give himself an access to file - only owner or administrator can.
using (_securityService.BeginSystemContext())
{
GiveFileAccessForIssue(issue, new User(update.ToEntity()));
}
}
}
}
else if (update.IsEntity(EntityConsts.Magazine) && update.ContainsRelation(User.ENTITY, Roles.Subscriber))
{
var rus = update.GetMultipleRelationUpdates(User.ENTITY, Roles.Subscriber).Where(ru => ru.Operation == RelationOperation.Attach);
if (rus.Count() > 0)
{
var q = new EntityQuery2(EntityConsts.Issue);
q.WhereRelated(new RelationQuery(EntityConsts.Magazine, Roles.Issue, update.Id.Value));
q.Include(File.ENTITY, Roles.Content);
var issues = _repository.Search(q);
foreach (var ru in rus)
{
foreach (var issue in issues)
GiveFileAccessForIssue(issue, new User(ru.Id.Value));
}
}
}
else if (update.IsEntity(EntityConsts.Magazine) && update.ContainsProperty("IsActive"))
{
var isActiveNew = update.Get<bool>("IsActive");
if (isActiveNew == false && context.Get<bool>(CTXKEY_ISACTIVEOLD))
{
SendMagazineNotActiveToSubscribers(update);
}
}
}
}
private void AppyLogicAfter(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
foreach (var logic in _logics)
logic.After(operation, context, result);
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (operation.IsEntity(Notification.ENTITY)
&& operation is EntityUpdate
&& context.Get<bool>(CTXKEY_CREATENOTIFICATION)
&& result.Success)
{
var update = operation as EntityUpdate;
var method = ReplyMethods.ByNotification;//default
if (update.ContainsProperty("Method"))
method = update.Get<ReplyMethods>("Method");
var recipientUpdate = update.GetRelationUpdate(User.ENTITY, Roles.Recipient);
var attachments = update.GetMultipleRelationUpdates(NbuLibrary.Core.Domain.File.ENTITY, Roles.Attachment);
if (attachments != null)
foreach (var att in attachments)
{
_fileService.GrantAccess(att.Id.Value, FileAccessType.Read, new User(recipientUpdate.Id.Value));
}
var recipientQuery = new EntityQuery2(User.ENTITY, recipientUpdate.Id.Value);
recipientQuery.AddProperty("Email");
var recipient = _repository.Read(recipientQuery);
var to = recipient.GetData<string>("Email");
var body = update.Get<string>("Body");
var subject = update.Get<string>("Subject");
}
}
public void After(Core.Services.tmp.EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
return;
var update = operation as EntityUpdate;
if (operation.IsEntity(EntityConsts.BibliographicListQuery) && update != null && update.ContainsProperty("Status") && update.Get<QueryStatus>("Status") == QueryStatus.Completed)
{
var q = new EntityQuery2(EntityConsts.BibliographicListQuery, update.Id.Value) { AllProperties = true };
q.Include(User.ENTITY, Roles.Customer);
var biblListQuery = _repository.Read(q);
var user = new User(biblListQuery.GetSingleRelation(User.ENTITY, Roles.Customer).Entity);
var template = _templateService.Get(new Guid(NotificationTemplates.QUERY_COMPLETED));
string subject = null, body = null;
Dictionary<string, Entity> templateContext = new Dictionary<string, Entity>(StringComparer.InvariantCultureIgnoreCase);
templateContext.Add("Customer", user);
templateContext.Add("Query", biblListQuery);
_templateService.Render(template, templateContext, out subject, out body);
var withEmail = biblListQuery.GetData<ReplyMethods>("ReplyMethod") == ReplyMethods.ByEmail;
_notificationService.SendNotification(withEmail, new User[] { user }, subject, body, null, new Relation[] { new Relation(Notification.ROLE, biblListQuery) });
}
else if (operation.IsEntity(Payment.ENTITY) && update != null && update.ContainsProperty("Status") && update.Get<PaymentStatus>("Status") == PaymentStatus.Paid)
{
var q = new EntityQuery2(EntityConsts.BibliographicListQuery);
q.AddProperties("Number");
q.WhereRelated(new RelationQuery(Payment.ENTITY, Roles.Payment, update.Id.Value));
q.Include(User.ENTITY, Roles.Customer);
q.Include(File.ENTITY, Roles.File);
var biblListQuery = _repository.Read(q);
if (biblListQuery != null)
{
var file = new File(biblListQuery.GetSingleRelation(File.ENTITY, Roles.File).Entity);
var user = new User(biblListQuery.GetSingleRelation(User.ENTITY, Roles.Customer).Entity);
var template = _templateService.Get(new Guid(NotificationTemplates.PAYMENT_COMPLETED));
string subject = null, body = null;
Dictionary<string, Entity> templateContext = new Dictionary<string, Entity>(StringComparer.InvariantCultureIgnoreCase);
templateContext.Add("Customer", user);
templateContext.Add("Query", biblListQuery);
_templateService.Render(template, templateContext, out subject, out body);
var withEmail = biblListQuery.GetData<ReplyMethods>("ReplyMethod") == ReplyMethods.ByEmail;
_notificationService.SendNotification(withEmail, new User[] { user }, subject, body, new File[] { file }, new Relation[] { new Relation(Notification.ROLE, biblListQuery) });
//_fileService.GrantAccess(file.Id, FileAccessType.Read, new User(biblQuery.GetSingleRelation(User.ENTITY, Roles.Customer).Entity));
}
}
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
return;
}
public void After(Services.tmp.EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
}
public void After(Services.tmp.EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (operation.IsEntity(NbuLibrary.Core.Domain.File.ENTITY)
&& operation is EntityDelete
&& result.Success)
{
var file = context.Get<NbuLibrary.Core.Domain.File>(CTXKEY_FILEDELETION);
if (file != null)
_fileService.DeleteFileContent(Guid.Parse(file.ContentPath));
}
}
public void After(EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
return;
if (!operation.IsEntity(User.ENTITY))
return;
var update = operation as EntityUpdate;
if (update == null)
return;
if (context.Get<bool>(CTXKEY_USER_PASSWORDRECOVERY))
{
var user = new User(_repository.Read(new EntityQuery2(update.Entity, update.Id.Value) { AllProperties = true }));
var template = _templateService.Get(new Guid(NotificationTemplates.USER_PASSWORDRECOVERY));
string subject = null, body = null;
Dictionary<string, Entity> templateContext = new Dictionary<string, Entity>(StringComparer.InvariantCultureIgnoreCase);
templateContext.Add("User", user);
_templateService.Render(template, templateContext, out subject, out body);
//TODO: async execution
_notificationService.SendEmail(user.Email, subject, body, null);
}
if (context.Get<bool>(CTXKEY_USER_CREATION))
{
var user = new User(_repository.Read(new EntityQuery2(update.Entity, update.Id.Value) { AllProperties = true }));
var pwd = context.Get<string>(CTXKEY_PASSWORD_UPDATE);
user.SetData<String>("Password", pwd);
var template = _templateService.Get(new Guid(NotificationTemplates.USER_CREATED));
string subject = null, body = null;
Dictionary<string, Entity> templateContext = new Dictionary<string, Entity>(StringComparer.InvariantCultureIgnoreCase);
templateContext.Add("User", user);
_templateService.Render(template, templateContext, out subject, out body);
//TODO: async execution
_notificationService.SendEmail(user.Email, subject, body, null);
if (update.ContainsProperty("IsActive") && update.Get<bool>("IsActive"))
SendUserActivationEmail(user);
}
else if (update.ContainsProperty("IsActive") && update.Get<bool>("IsActive"))
{
var user = new User(_repository.Read(new EntityQuery2(update.Entity, update.Id.Value) { AllProperties = true }));
SendUserActivationEmail(user);
}
else if (context.Get<int>(CTXKEY_UPDATE_PROFILE) > 0)
{
if (update.ContainsRelation("UserGroup", "UserGroup")
|| update.ContainsProperty("FacultyNumber")
|| update.ContainsProperty("CardNumber"))
{
var user = new User(context.Get<int>(CTXKEY_UPDATE_PROFILE));
user.IsActive = false;
_repository.Update(user);
_securityService.Logout();
result.Data.Add("account_warning_logged_out", true);
}
if (update.ContainsProperty("Email"))
{
_securityService.UpdateCurrentUserEmail(update.Get<string>("Email"));
result.Data.Add("account_event_email_changed", update.Get<string>("Email"));
}
}
}
public void After(Services.tmp.EntityOperation operation, EntityOperationContext context, EntityOperationResult result)
{
if (!result.Success)
return;
using (var dbContext = _dbService.GetDatabaseContext(true))
{
if (operation is EntityDelete)
{
LogOperation(operation.Entity, operation.Id.Value, HistoryOperation.Deleted, DateTime.Now, dbContext.Connection);
}
else if (operation is EntityUpdate)
{
var update = operation as EntityUpdate;
bool created = result.Data.ContainsKey("Created");
var now = DateTime.Now;
int opId = LogOperation(update.Entity, update.Id.Value, created ? HistoryOperation.Created : HistoryOperation.Modified, now, dbContext.Connection);
foreach (var propUpdate in update.PropertyUpdates)
{
LogPropertyChange(opId, propUpdate.Key, propUpdate.Value, dbContext.Connection);
}
foreach (var relUpdate in update.RelationUpdates)
{
int relChangeId = LogRelationChange(opId, relUpdate.Entity, relUpdate.Role, relUpdate.Id.Value, relUpdate.Operation, dbContext.Connection);
foreach (var propUpdate in relUpdate.PropertyUpdates)
{
LogRelationPropertyChange(relChangeId, propUpdate.Key, propUpdate.Value, dbContext.Connection);
}
}
}
dbContext.Complete();
}
}
