public void CreateCollection(CollectionEntityDto collectionDto)
{
var collectionEntity = Mapper.Map <Collections>(collectionDto);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
unitOfWork.Queue(new EntityCommand <Collections>(CommandType.CREATE, collectionEntity));
}
public void FactoryCreatesUnitOfWorkWithNewNestedContainer(Mock <IDbTransaction> transactionMock, Mock <IDboContext> contextMock)
{
var container = new Container(new DataRegistry());
container.Configure(_ => _.For <IDbTransaction>().Use(transactionMock.Object));
container.Configure(_ => _.For <IDboContext>().Use(contextMock.Object));
var uowFactory = new UnitOfWorkFactory(container);
var uow1 = uowFactory.GetUnitOfWork();
var uow2 = uowFactory.GetUnitOfWork();
Assert.IsType <UnitOfWork>(uow1);
Assert.NotSame(container, ((UnitOfWork)uow1).container);
Assert.NotSame(((UnitOfWork)uow1).container, ((UnitOfWork)uow2).container);
}
public void DeleteCoin(Guid coinId)
{
var coinEntity = Context.Find(typeof(Coins), coinId) as Coins;
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
unitOfWork.Queue(new EntityCommand <Coins>(CommandType.DELETE, coinEntity));
}
public void UnitOfWorkContainerProducesCorrectContext(Mock <IDbTransaction> transactionMock, Mock <IDboContextFactory> contextFactoryMock)
{
contextFactoryMock.Setup(c => c.GetContext()).Returns(() => new Mock <IDboContext>().Object);
var container = new Container(new DataRegistry());
container.Configure(_ => _.For <IDbTransaction>().Use(transactionMock.Object));
container.Configure(_ => _.For <IDboContext>().Use(() => contextFactoryMock.Object.GetContext()).AlwaysUnique());
container.Configure(_ => _.Profile(Profile.UnitOfWork, p => p.For <IDboContext>().Use(c => contextFactoryMock.Object.GetContext())));
var uowFactory = new UnitOfWorkFactory(container);
using (var uow = uowFactory.GetUnitOfWork())
{
var nestedContainer = ((UnitOfWork)uow).container;
// Show that using the global container produces a new dbo context
Assert.NotSame(((UnitOfWork)uow).dboContext, ((DocumentRepository)container.GetInstance <IDocumentRepository>()).db);
// Nested container produces the same dbo context
Assert.Same(((UnitOfWork)uow).dboContext, ((DocumentRepository)nestedContainer.GetInstance <IDocumentRepository>()).db);
}
// Once for the global container and a second time for the nested container
contextFactoryMock.Verify(cf => cf.GetContext(), Times.Exactly(2));
}
public void UpdateCoin(Guid collectionId, CoinEntityDto coinEntityDto)
{
var coinEntity = Mapper.Map <Coins>(coinEntityDto);
coinEntity.CollectionId = collectionId;
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
unitOfWork.Queue(new EntityCommand <Coins>(CommandType.UPDATE, coinEntity));
}
public ResponseDto <User> UpdateUser(User User)
{
var response = new ResponseDto <User>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <User>();
var repositoryTeam = unitOfWork.GetGenericRepository <Team>();
IQueryable <User> users = repo.GetAll();
response.Data = users.FirstOrDefault(x => x.UserId == User.UserId);
if (response.Data == null)
{
response.StatusCode = StatusCode.Warning;
return(response);
}
var validation = ModelHelperValidator.ValidateComponentModel(User);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
User.UserName = User.UserName.Trim();
User.FirstName = User.FirstName.Trim();
User.LastName = User.LastName.Trim();
User.EmailAddress = User.EmailAddress.Trim();
if (users.Any(x => x.UserName == User.UserName) && User.UserName != response.Data.UserName)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The UserName already exists in the system.";
return(response);
}
if (User.TeamId != null && !repositoryTeam.GetAll().Any(x => x.TeamId == User.TeamId))
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The Team doesn't exist in the system.";
return(response);
}
response.Data.UserId = User.UserId;
response.Data.UserName = User.UserName;
response.Data.FirstName = User.FirstName;
response.Data.LastName = User.LastName;
response.Data.EmailAddress = User.EmailAddress;
response.Data.TeamId = User.TeamId;
repo.UpdateAndSave(response.Data);
return(response);
}
}
protected override void Initialize(HttpControllerContext controllerContext)
{
try
{
UnitOfWork = UnitOfWorkFactory.GetUnitOfWork(Global.ConnectionString.ToString(), "SQL");
}
catch (Exception ex)
{
}
base.Initialize(controllerContext);
}
public ResponseDto <Team> UpdateTeam(Team Team)
{
var response = new ResponseDto <Team>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <Team>();
var repositoryProject = unitOfWork.GetGenericRepository <Project>();
IQueryable <Team> teams = repo.GetAll();
response.Data = teams.FirstOrDefault(x => x.TeamId == Team.TeamId);
if (response.Data == null)
{
response.StatusCode = StatusCode.Warning;
return(response);
}
var validation = ModelHelperValidator.ValidateComponentModel(Team);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
if (teams.Any(x => x.TeamName == Team.TeamName) && Team.TeamName != response.Data.TeamName)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The team name already exists in the system.";
return(response);
}
if (!repositoryProject.GetAll().Any(x => x.ProjectId == Team.ProjectId))
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The project doesn't exist in the system.";
return(response);
}
response.Data.TeamId = Team.TeamId;
response.Data.TeamName = Team.TeamName;
response.Data.ProjectId = Team.ProjectId;
repo.UpdateAndSave(response.Data);
return(response);
}
}
public ResponseDto <Team> AddTeam(Team Team)
{
var response = new ResponseDto <Team> {
StatusCode = StatusCode.Error
};
var validation = ModelHelperValidator.ValidateComponentModel(Team);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repository = unitOfWork.GetGenericRepository <Team>();
var repositoryProject = unitOfWork.GetGenericRepository <Project>();
Team.TeamName = Team.TeamName.Trim();
if (repository.GetAll().Any(x => x.TeamName == Team.TeamName))
{
response.StatusMessage = "The team name already exists in the system.";
return(response);
}
if (!repositoryProject.GetAll().Any(x => x.ProjectId == Team.ProjectId))
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The project doesn't exist in the system.";
return(response);
}
Team.CreatedDt = DateTime.Now;
repository.InsertAndSave(Team);
response.StatusCode = StatusCode.Successful;
response.Data = Team;
}
return(response);
}
public ResponseDto <Activity> UpdateActivity(Activity Activity)
{
var response = new ResponseDto <Activity>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <Activity>();
var repositoryTeam = unitOfWork.GetGenericRepository <Team>();
IQueryable <Activity> activities = repo.GetAll();
response.Data = activities.FirstOrDefault(x => x.ActivityId == Activity.ActivityId);
if (response.Data == null)
{
response.StatusCode = StatusCode.Warning;
return(response);
}
var validation = ModelHelperValidator.ValidateComponentModel(Activity);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
if (!repositoryTeam.GetAll().Any(x => x.TeamId == Activity.TeamId))
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The team doesn't exist in the system.";
return(response);
}
response.Data.ActivityId = Activity.ActivityId;
response.Data.Description = Activity.Description;
response.Data.StartDate = Activity.StartDate;
response.Data.DueDate = Activity.DueDate;
repo.UpdateAndSave(response.Data);
return(response);
}
}
public ResponseDto <User> GetUserById(int id)
{
var response = new ResponseDto <User>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <User>();
response.Data = repo.GetAll().FirstOrDefault(x => x.UserId == id);
if (response.Data == null)
{
response.StatusCode = StatusCode.Error;
}
return(response);
}
}
public ResponseDto <Project> UpdateProject(Project project)
{
var response = new ResponseDto <Project>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <Project>();
response.Data = repo.GetAll().FirstOrDefault(x => x.ProjectId == project.ProjectId);
if (response.Data == null)
{
response.StatusCode = StatusCode.Warning;
return(response);
}
var validation = ModelHelperValidator.ValidateComponentModel(project);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
if (repo.GetAll().Any(x => x.ProjectName == project.ProjectName) && project.ProjectName != response.Data.ProjectName)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The project name already exits in the system.";
return(response);
}
response.Data.ProjectName = project.ProjectName;
response.Data.Description = project.Description;
response.Data.StartDate = project.StartDate;
response.Data.EndDate = project.EndDate;
repo.UpdateAndSave(response.Data);
return(response);
}
}
public ResponseDto <User> AddUser(User User)
{
var response = new ResponseDto <User> {
StatusCode = StatusCode.Error
};
var validation = ModelHelperValidator.ValidateComponentModel(User);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repository = unitOfWork.GetGenericRepository <User>();
User.UserName = User.UserName.Trim();
User.FirstName = User.FirstName.Trim();
User.LastName = User.LastName.Trim();
User.EmailAddress = User.EmailAddress.Trim();
if (repository.GetAll().Any(x => x.UserName == User.UserName))
{
response.StatusMessage = "The UserName already exists in the system.";
return(response);
}
User.CreatedDt = DateTime.Now;
repository.InsertAndSave(User);
response.StatusCode = StatusCode.Successful;
response.Data = User;
}
return(response);
}
public ResponseDto <Deliverable> UpdateDeliverable(Deliverable Deliverable)
{
var response = new ResponseDto <Deliverable>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <Deliverable>();
response.Data = repo.GetAll().FirstOrDefault(x => x.DeliverableId == Deliverable.DeliverableId);
if (response.Data == null)
{
response.StatusCode = StatusCode.Warning;
return(response);
}
var validation = ModelHelperValidator.ValidateComponentModel(Deliverable);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
if (repo.GetAll().Any(x => x.DeliverableId == Deliverable.DeliverableId) && Deliverable.DeliverableId != response.Data.DeliverableId)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The Deliverable name already exits in the system.";
return(response);
}
response.Data.DeliverableId = Deliverable.DeliverableId;
response.Data.Description = Deliverable.Description;
response.Data.DueDate = Deliverable.DueDate;
repo.UpdateAndSave(response.Data);
return(response);
}
}
public void UnitOfWorkReusesSameDbContext(Mock <IDbTransaction> transactionMock, Mock <IDboContextFactory> contextFactoryMock)
{
contextFactoryMock.Setup(c => c.GetContext()).Returns(() => new Mock <IDboContext>().Object);
var container = new Container(new DataRegistry());
container.Configure(_ => _.For <IDbTransaction>().Use(transactionMock.Object));
container.Configure(_ => _.For <IDboContext>().Use(() => contextFactoryMock.Object.GetContext()).AlwaysUnique());
container.Configure(_ => _.Profile(Profile.UnitOfWork, p => p.For <IDboContext>().Use(c => contextFactoryMock.Object.GetContext())));
var uowFactory = new UnitOfWorkFactory(container);
using (var uow = uowFactory.GetUnitOfWork())
{
Assert.Same(((UnitOfWork)uow).dboContext, ((DocumentRepository)((UnitOfWork)uow).DocumentMetaData).db);
Assert.Same(((UnitOfWork)uow).dboContext, ((ExceptionLogRepository)((UnitOfWork)uow).Exceptions).db);
}
contextFactoryMock.Verify(cf => cf.GetContext(), Times.Once);
}
public ResponseDto <Activity> AddActivity(Activity Activity)
{
var response = new ResponseDto <Activity> {
StatusCode = StatusCode.Error
};
var validation = ModelHelperValidator.ValidateComponentModel(Activity);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repository = unitOfWork.GetGenericRepository <Activity>();
var repositoryTeam = unitOfWork.GetGenericRepository <Team>();
Activity.Description = Activity.Description.Trim();
Activity.CreatedDt = DateTime.Now;
if (!repositoryTeam.GetAll().Any(x => x.TeamId == Activity.TeamId))
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = "The Team doesn't exist in the system.";
return(response);
}
repository.InsertAndSave(Activity);
response.StatusCode = StatusCode.Successful;
response.Data = Activity;
}
return(response);
}
public ResponseDto <Deliverable> AddDeliverable(Deliverable Deliverable)
{
var response = new ResponseDto <Deliverable> {
StatusCode = StatusCode.Error
};
var validation = ModelHelperValidator.ValidateComponentModel(Deliverable);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repository = unitOfWork.GetGenericRepository <Deliverable>();
Deliverable.DeliverableId = Deliverable.DeliverableId;
Deliverable.Description = Deliverable.Description.Trim();
if (repository.GetAll().Any(x => x.DeliverableId == Deliverable.DeliverableId))
{
response.StatusMessage = "The Deliverable name already exits in the system.";
return(response);
}
Deliverable.CreatedDt = DateTime.Now;
repository.InsertAndSave(Deliverable);
response.StatusCode = StatusCode.Successful;
response.Data = Deliverable;
}
return(response);
}
public ResponseDto <Project> AddProject(Project project)
{
var response = new ResponseDto <Project> {
StatusCode = StatusCode.Error
};
var validation = ModelHelperValidator.ValidateComponentModel(project);
if (!validation.Data)
{
response.StatusCode = StatusCode.Error;
response.StatusMessage = validation.StatusMessage.Trim();
return(response);
}
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repository = unitOfWork.GetGenericRepository <Project>();
project.ProjectName = project.ProjectName.Trim();
project.Description = project.Description.Trim();
if (repository.GetAll().Any(x => x.ProjectName == project.ProjectName))
{
response.StatusMessage = "The project name already exits in the system.";
return(response);
}
project.CreatedDt = DateTime.Now;
repository.InsertAndSave(project);
response.StatusCode = StatusCode.Successful;
response.Data = project;
}
return(response);
}
public ResponseDto <bool> DeleteUser(int id)
{
var response = new ResponseDto <bool>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <User>();
var User = repo.GetAll().FirstOrDefault(x => x.UserId == id);
if (User == null)
{
response.StatusCode = StatusCode.Error;
return(response);
}
repo.Delete(User);
repo.Save();
return(response);
}
}
public ResponseDto <bool> DeleteProject(int id)
{
var response = new ResponseDto <bool>(StatusCode.Successful);
using (var unitOfWork = UnitOfWorkFactory.GetUnitOfWork())
{
var repo = unitOfWork.GetGenericRepository <Project>();
var project = repo.GetAll().FirstOrDefault(x => x.ProjectId == id);
if (project == null)
{
response.StatusCode = StatusCode.Error;
return(response);
}
repo.Delete(project);
repo.Save();
response.Data = true;
return(response);
}
}
static void Main(string[] args)
{
Console.WriteLine("Enter Enagement id");
int eng = Convert.ToInt32(Console.ReadLine());
using (IUnitOfWorkFactory fac = new UnitOfWorkFactory())
{
IUnitOfWork uow = fac.GetUnitOfWork(eng);
IRepository <User> user = uow.GetRepository <User>();
//User u = new User
//{
// Email = "random",
// FirstName = "Random",
// LastName = "Random",
// CreatedBy = "Random",
// CreatedDate = DateTime.Now,
// ModifiedBy = "Random",
// ModifiedDate = DateTime.Now,
//};
//user.Insert(u);
// uow.Commit();
var k = user.Query <User>().Select(x => x).ToList();
}
}
public TUnitOfWork GetCurrentUnitOfWork<TUnitOfWork>() where TUnitOfWork : IUnitOfWork
{
return (TUnitOfWork)UnitOfWorkFactory.GetUnitOfWork();
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
//Lấy thông tin action
var action = HttpContext.Current.Request.RequestContext.RouteData.Values["action"].ToString();
string TokenId = actionContext.Request.Headers.GetValues("Udemi-Token").FirstOrDefault().ToString();
if (TokenId.IsNullOrWhiteSpace())
{
var response = new HttpResponseMessage(HttpStatusCode.PreconditionFailed)
{
Content = new StringContent("Token is empty.")
};
actionContext.Response = response;
return;
}
UnitOfWork = UnitOfWorkFactory.GetUnitOfWork(Global.ConnectionString.ToString(), "SQL");
Token getTk = UnitOfWork.Token.GetToken(TokenId);
if (getTk.TokenId == null)
{
var response = new HttpResponseMessage(HttpStatusCode.PreconditionFailed)
{
Content = new StringContent("Invalid Token.")
};
actionContext.Response = response;
return;
}
//Kiểm tra action
bool checkteacher = false;
bool checkadministrator = false;
foreach (var item in lstactionTeacher)
{
if (item.Equals(action))
{
checkteacher = true;
}
}
foreach (var item in lstactionAdministrtor)
{
if (item.Equals(action))
{
checkadministrator = true;
}
}
if (checkteacher)
{
//Kiểm tra usertype
if (!getTk.User_Type.Equals("T"))
{
var response = new HttpResponseMessage(HttpStatusCode.PreconditionFailed)
{
Content = new StringContent("Wrong Type token.")
};
actionContext.Response = response;
return;
}
}
if (checkadministrator)
{
//Kiểm tra usertype
if (!getTk.User_Type.Equals("A"))
{
var response = new HttpResponseMessage(HttpStatusCode.PreconditionFailed)
{
Content = new StringContent("Wrong Type token.")
};
actionContext.Response = response;
return;
}
}
}
private Reponsitory GetContext()
{
return(UnitOfWorkFactory.GetUnitOfWork(_sqlDbName, DbSupportType.MicrosoftSqlServer));
}
public static IUnitOfWork GetUnitOfWork(IServiceProvider services) => UnitOfWorkFactory.GetUnitOfWork(Get);
