public async Task <IResult> UpdateAsync(long facultyId, UpdateFacultyModel updateFacultyModel)
{
var validation = new FacultyModelValidator().Valid(updateFacultyModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var facultyEntity = await FacultyRepository.SelectAsync(facultyId);
var nullObjectValidation = new NullObjectValidation <FacultyEntity>().Valid(facultyEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var facultyDomain = FacultyDomainFactory.Create(facultyEntity);
facultyDomain.Update(updateFacultyModel);
facultyEntity = facultyDomain.Map <FacultyEntity>();
facultyEntity.FacultyId = facultyId;
await FacultyRepository.UpdateAsync(facultyEntity, facultyEntity.FacultyId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
private async Task <IResult> Update(UpdateDepartmentLessonModel updateDepartmentLessonModel, Expression <Func <DepartmentLessonEntity, bool> > where)
{
var validation = new UpdateDepartmentLessonModelValidator().Valid(updateDepartmentLessonModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var DepartmentLessonEntity = await DepartmentLessonRepository.SingleOrDefaultAsync(where);
var nullObjectValidation = new NullObjectValidation <DepartmentLessonEntity>().Valid(DepartmentLessonEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var DepartmentLessonDomain = DepartmentLessonDomainFactory.Create(DepartmentLessonEntity);
DepartmentLessonDomain.Update(updateDepartmentLessonModel);
DepartmentLessonEntity = DepartmentLessonDomain.Map <DepartmentLessonEntity>();
await DepartmentLessonRepository.UpdateAsync(DepartmentLessonEntity, DepartmentLessonEntity.DepartmentLessonId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public VanillaWorld(int portNumber, int maxConnections)
{
DBC = new DBCLibrary();
WorldDatabase = new DatabaseUnitOfWork <WorldDatabase>();
CharacterDatabase = new DatabaseUnitOfWork <CharacterDatabase>();
Server = new WorldServer(this);
Components.Add(new ActionButtonComponent(this));
Components.Add(new AuthComponent(this));
Components.Add(new CharacterComponent(this));
Components.Add(new ChatMessageComponent(this));
Components.Add(new WeatherComponent(this));
Components.Add(new EntityComponent(this));
Components.Add(new GameObjectComponent(this));
Components.Add(new LoginComponent(this));
Components.Add(new LogoutComponent(this));
Components.Add(new MailComponent(this));
Components.Add(new MiscComponent(this));
Components.Add(new PlayerMovementComponent(this));
Components.Add(new SpellComponent(this));
ChatCommands = new ChatCommandParser();
Server.Start(portNumber, maxConnections);
var accountCreator = new AccountCreator();
accountCreator.CreateAccount("andrew", "password");
accountCreator.CreateAccount("lucas", "password");
}
public async Task <IDataResult <long> > Add(AddStudentModel addStudentModel)
{
var validation = new AddStudentModelValidator().Valid(addStudentModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
StudentDomain domain = new StudentDomain(DatabaseUnitOfWork, StudentRepository, CourseRepository);
var student = domain.ConvertToStudentEntity(addStudentModel);
string errorMessage = await domain.ApplyBusinessRules(student);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
return(new ErrorDataResult <long>(errorMessage));
}
await StudentRepository.AddAsync(student);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(student.StudentId));
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var userEntityDatabase = await UserRepository.SelectAsync(updateUserModel.UserId).ConfigureAwait(false);
var userDomain = UserDomainFactory.Create(updateUserModel);
userDomain.SetLogin(userEntityDatabase.Login);
userDomain.SetPassword(userEntityDatabase.Password);
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.UpdateAsync(userEntity, userEntity.UserId).ConfigureAwait(false);
await DatabaseUnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(new SuccessResult());
}
public void Save(UserLogModel userLogModel)
{
var userLogEntity = userLogModel.Map <UserLogEntity>();
UserLogRepository.Add(userLogEntity);
DatabaseUnitOfWork.SaveChanges();
}
public async Task <IDataResult <long> > AddAsync(AddLessonModel addLessonModel)
{
var validation = new LessonModelValidator().Valid(addLessonModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var lessonDomain = LessonDomainFactory.Create(addLessonModel);
lessonDomain.Add();
var lessonEntity = lessonDomain.Map <LessonEntity>();
addLessonModel.LessonGroupTypes.ForEach(x => {
var domain = LessonGroupDomainFactory.Create(x, lessonEntity.LessonId);
lessonEntity.LessonGroups.Add(domain.Map <LessonGroupEntity>());
});
await LessonRepository.AddAsync(lessonEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(lessonEntity.LessonId));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
addUserModel.Login = UserDomainService.GenerateHash(addUserModel.Login);
addUserModel.Password = UserDomainService.GenerateHash(addUserModel.Password);
var userDomain = UserDomainFactory.Create(addUserModel);
userDomain.Add();
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.AddAsync(userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(userEntity.UserId));
}
public async Task <IResult> UpdateAsync(long userId, UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(userId);
var nullObjectValidation = new NullObjectValidation <UserEntity>().Valid(userEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var userDomain = UserDomainFactory.Create(userEntity);
userDomain.Update(updateUserModel);
userEntity = userDomain.Map <UserEntity>();
userEntity.UserId = userId;
await UserRepository.UpdateAsync(userEntity, userEntity.UserId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(updateUserModel.UserId);
if (userEntity == default)
{
return(SuccessResult());
}
userEntity.UpdateEmail(updateUserModel.Email);
userEntity.UpdateFullName(updateUserModel.FullName.Name, updateUserModel.FullName.Surname);
await UserRepository.UpdateAsync(userEntity.UserId, userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
public async Task <IResult> UpdateAsync(long departmentId, UpdateDepartmentModel updateDepartmentModel)
{
var validation = new DepartmentModelValidator().Valid(updateDepartmentModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var DepartmentEntity = await DepartmentRepository.SelectAsync(departmentId);
var nullObjectValidation = new NullObjectValidation <DepartmentEntity>().Valid(DepartmentEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var DepartmentDomain = DepartmentDomainFactory.Create(DepartmentEntity);
DepartmentDomain.Update(updateDepartmentModel);
DepartmentEntity = DepartmentDomain.Map <DepartmentEntity>();
DepartmentEntity.DepartmentId = departmentId;
await DepartmentRepository.UpdateAsync(DepartmentEntity, DepartmentEntity.DepartmentId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public void Save(long userId, LogType logType)
{
var userLog = UserLogFactory.Create(userId, logType);
DatabaseUnitOfWork.UserLogRepository.Add(userLog);
DatabaseUnitOfWork.SaveChanges();
}
public async Task <IResult> UpdateAsync(long constraintId, UpdateConstraintModel updateConstraintModel)
{
var validation = new UpdateConstraintModelValidator().Valid(updateConstraintModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var constraintEntity = await ConstraintRepository.SelectAsync(constraintId);
var nullObjectValidation = new NullObjectValidation <ConstraintEntity>().Valid(constraintEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var constraintDomain = ConstraintDomainFactory.Create(constraintEntity);
constraintDomain.Update(updateConstraintModel);
constraintEntity = constraintDomain.Map <ConstraintEntity>();
await ConstraintRepository.UpdateAsync(constraintEntity, constraintEntity.ConstraintId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> UpdateAsync(long lessonId, UpdateLessonModel updateLessonModel)
{
var validation = new LessonModelValidator().Valid(updateLessonModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var lessonEntity = await LessonRepository.SelectAsync(lessonId);
var nullObjectValidation = new NullObjectValidation <LessonEntity>().Valid(lessonEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var lessonDomain = LessonDomainFactory.Create(lessonEntity);
lessonDomain.Update(updateLessonModel);
lessonEntity = lessonDomain.Map <LessonEntity>();
lessonEntity.LessonId = lessonId;
await LessonRepository.UpdateAsync(lessonEntity, lessonEntity.LessonId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public static item_template[] GenerateInventoryByIDs(int[] ids)
{
if (ids == null) return null;
item_template[] inventory = new item_template[19];
for (int i = 0; i < ids.Length; i++)
{
if (ids[i] > 0)
{
var itemEntry = ids[i];
item_template item = new DatabaseUnitOfWork<WorldDatabase>().GetRepository<item_template>().SingleOrDefault(it => it.entry == itemEntry);
switch ((InventorySlotID)item.InventoryType)
{
case InventorySlotID.Head:
inventory[0] = item;
break;
case InventorySlotID.Shirt:
inventory[3] = item;
break;
case InventorySlotID.Vest:
case InventorySlotID.Robe:
inventory[4] = item;
break;
case InventorySlotID.Waist:
inventory[5] = item;
break;
case InventorySlotID.Legs:
inventory[6] = item;
break;
case InventorySlotID.Feet:
inventory[7] = item;
break;
case InventorySlotID.Wrist:
inventory[8] = item;
break;
case InventorySlotID.Hands:
inventory[9] = item;
break;
case InventorySlotID.Ring:
inventory[10] = item;
break;
case InventorySlotID.Trinket:
inventory[12] = item;
break;
case InventorySlotID.Mainhand:
case InventorySlotID.Onehand:
case InventorySlotID.Twohand:
inventory[15] = item;
break;
case InventorySlotID.Offhand:
case InventorySlotID.Shield:
case InventorySlotID.Bow:
inventory[16] = item;
break;
}
}
}
return inventory;
}
public async Task <IResult> DeleteAsync(long userId)
{
await UserRepository.DeleteAsync(userId).ConfigureAwait(false);
await DatabaseUnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(new SuccessResult());
}
public Task <IResult <string> > DeleteAsync(long userId)
{
UserRepository.Delete(userId);
DatabaseUnitOfWork.SaveChanges();
return(new SuccessResult <string>().ToTask());
}
public async Task <IResult> DeleteLessonAsync(long DepartmentId, long lessonId)
{
await DepartmentLessonRepository.DeleteAsync(x => x.DepartmentId == DepartmentId && x.LessonId == lessonId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> DeleteAsync(long lessonId)
{
await LessonRepository.DeleteAsync(lessonId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> DeleteAsync(long constraintId)
{
await ConstraintRepository.DeleteAsync(constraintId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public Task AddAsync(UserLogModel userLogModel)
{
var userLogEntity = userLogModel.Map <UserLogEntity>();
UserLogRepository.AddAsync(userLogEntity);
return(DatabaseUnitOfWork.SaveChangesAsync());
}
public async Task <IResult> DeleteAsync(long userId)
{
await UserRepository.DeleteAsync(userId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
private void OnAuthSession(WorldSession session, PCAuthSession packet)
{
account account = new DatabaseUnitOfWork<LoginDatabase>().GetRepository<account>().SingleOrDefault((a) => a.username == packet.Username);
session.Account = account;
session.PacketCrypto = new VanillaCrypt();
session.PacketCrypto.init(Utils.HexToByteArray(session.Account.sessionkey));
session.SendPacket(new PSAuthResponse());
}
private void OnAuthSession(WorldSession session, PCAuthSession packet)
{
account account = new DatabaseUnitOfWork <LoginDatabase>().GetRepository <account>().SingleOrDefault((a) => a.username == packet.Username);
session.Account = account;
session.PacketCrypto = new VanillaCrypt();
session.PacketCrypto.init(Utils.HexToByteArray(session.Account.sessionkey));
session.SendPacket(new PSAuthResponse());
}
public async Task InactivateAsync(long userId)
{
var userEntity = UserEntityFactory.Create(userId);
userEntity.Inactivate();
await UserRepository.UpdatePartialAsync(userEntity.UserId, new { userEntity.Status });
await DatabaseUnitOfWork.SaveChangesAsync();
}
public async Task <IResult> UpdateUserAsync(long departmentId, long headOfDepartmentId)
{
var DepartmentEntity = await DepartmentRepository.SelectAsync(departmentId);
var DepartmentDomain = DepartmentDomainFactory.Create(DepartmentEntity);
await DepartmentRepository.UpdateAsync(DepartmentEntity, DepartmentEntity.DepartmentId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
protected override void RunTask()
{
using IUnitOfWork unitOfWork = new DatabaseUnitOfWork();
var dataTransferLogic = LogicFactory.GetLogicFactory().CreateDataTransferLogic(unitOfWork);
var taskIds = dataTransferLogic.GetTaskIdsWithOpenTunnels();
LogicFactory.GetLogicFactory().CreateJobManagementLogic(unitOfWork).GetAllFinishedTaskInfos(taskIds)
.ToList()
.ForEach(f => dataTransferLogic.CloseAllTunnelsForTask(f));
}
private void SaveUserLog(long userId, LogType logType)
{
var userLog = new UserLogModel
{
UserId = userId,
LogType = logType,
DateTime = DateTime.Now
};
DatabaseUnitOfWork.UserLogRepository.Add(userLog);
DatabaseUnitOfWork.Commit();
}
public async Task AddAsync(UserLogModel userLogModel)
{
var userLogDomain = UserLogDomainFactory.Create(userLogModel);
userLogDomain.Add();
var userLogEntity = UserLogEntityFactory.Create(userLogDomain);
await UserLogRepository.AddAsync(userLogEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
}
public async Task <IResult> InactivateAsync(long userId)
{
var userDomain = UserDomainFactory.Create(userId);
userDomain.Inactivate();
await UserRepository.UpdatePartialAsync(userDomain.UserId, new { userDomain.Status });
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
public void GetAll_DTO_Success()
{
//Arrange
using (var context = new ManagementContext())
{
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
var sut = new CustomersService(customerRepository);
Mapper.CreateMap<Customer, CustomerDTO>()
.ForMember(dst => dst.CustomerId, opt => opt.MapFrom(src => src.Id));
Assert.Greater(sut.GetAll_DTO("C").Count(), 0);
}
}
public void GetAll_DTO_Success()
{
//Arrange
using (var context = new ManagementContext())
{
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
var sut = new CustomersService(customerRepository);
Mapper.CreateMap <Customer, CustomerDTO>()
.ForMember(dst => dst.CustomerId, opt => opt.MapFrom(src => src.Id));
Assert.Greater(sut.GetAll_DTO("C").Count(), 0);
}
}
protected override void RunTask()
{
if (BusinessLogicConfiguration.ClusterAccountRotation)
{
using IUnitOfWork unitOfWork = new DatabaseUnitOfWork();
//Get all jobs in state - waiting for user
IEnumerable <SubmittedJobInfo> allWaitingJobs = unitOfWork.SubmittedJobInfoRepository.GetAllWaitingForServiceAccount();
//Try to submit them again
foreach (SubmittedJobInfo job in allWaitingJobs)
{
LogicFactory.GetLogicFactory().CreateJobManagementLogic(unitOfWork).SubmitJob(job.Id, job.Submitter);
}
}
}
public void Remove_Customer_Succeed()
{
using (var context = new ManagementContext())
{
//Arrange
var total = context.Customers.Count();
var customer = context.Customers.First();
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
customerRepository.Remove(customer);
unitOfWork.Save();
//Assert
Assert.AreEqual(context.Customers.Count(), total - 1);
}
}
public void Save_Customer_Succeed()
{
using (var context = new ManagementContext())
{
//Arrange
var customer = context.Customers.First();
customer.Name = "Cliente modificado";
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
customerRepository.Save(customer);
unitOfWork.Save();
//Assert
Assert.Pass();
}
}
public void Save_NewCustomer_Succeed()
{
using (var context = new ManagementContext())
{
//Arrange
var customer = new Customer()
{
Name = "Nuevo cliente"
};
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
customerRepository.Save(customer);
unitOfWork.Save();
//Assert
Assert.Pass();
}
}
public void GetAllWithPredicate_Customer_Succeed()
{
//Arrange
InsertCustomers(20);
using (var context = new ManagementContext())
{
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
var total = customerRepository.GetAll(CustomerRepository.Predicates(p => p.Id > 5), null).Count();
//Assert
Assert.AreEqual(15, total);
}
}
public AccountCreator()
{
LoginDatabase = new DatabaseUnitOfWork<LoginDatabase>();
}
public void GetPaginated_Customer_Succeed(PaginatedData paginatedData)
{
//Arrange
using (var context = new ManagementContext())
{
var executor = new SqlExecutor(context.Database.Connection.ConnectionString);
executor.ExecuteScript(Path.Combine(Environment.CurrentDirectory, "Scripts", "2 - Customers.sql"));
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
PaginatedResult<Customer> result = customerRepository.GetPaginated(null, null, p => p.Id, paginatedData.PageIndex, paginatedData.PageSize);
//Assert
Assert.AreEqual(paginatedData.ResultCount, result.Result.Count());
Assert.AreEqual(paginatedData.PageIndex, result.PageIndex);
Assert.AreEqual(paginatedData.PageSize, result.PageSize);
Assert.AreEqual(paginatedData.TotalCount, result.TotalCount);
Assert.AreEqual(paginatedData.TotalPageCount, result.TotalPageCount);
Assert.AreEqual(paginatedData.HasPreviousPage, result.HasPreviousPage);
Assert.AreEqual(paginatedData.HasNextPage, result.HasNextPage);
}
}
public void GetAllWithPredicates_Customer_Succeed()
{
//Arrange
using (var context = new ManagementContext())
{
var executor = new SqlExecutor(context.Database.Connection.ConnectionString);
executor.ExecuteScript(Path.Combine(Environment.CurrentDirectory, "Scripts", "2 - Customers.sql"));
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
var predicates = CustomerRepository.Predicates(p => p.Id > 2, p => p.Code.StartsWith("A"));
var total = customerRepository.GetAll<Customer>(predicates, null, null).Count();
//Assert
Assert.AreEqual(3, total);
}
}
public void GetAll_Customer_Succeed()
{
//Arrange
InsertCustomers(20);
using (var context = new ManagementContext())
{
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
var total = customerRepository.GetAll().Count();
//Assert
Assert.AreEqual(20, total);
}
}
