public async void TestForCreateEquipmentRequest()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3ControllerCreateRequest")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
Logic l = new Logic(r, new NullLogger <Repo>());
Mapper m = new Mapper();
EquipmentController controller = new EquipmentController(l, m);
var request = new CreateEquipmentRequestDto
{
TeamID = Guid.NewGuid(),
UserID = "fred",
Message = "i need equipment now!",
Status = "Approved",
ItemID = 53,
};
var createRequest = await controller.CreateEquipmentRequest(request);
Assert.Equal("fred", createRequest.Value.UserID);
Assert.Equal("i need equipment now!", createRequest.Value.Message);
Assert.Equal(53, createRequest.Value.ItemId);
Assert.Equal("Approved", createRequest.Value.Status);
}
}
public async void TestForGetEquipmentItems()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3GetItems")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
var item = new EquipmentItem
{
EquipmentID = 43,
Description = "golf club"
};
r.EquipmentItems.Add(item);
var item2 = new EquipmentItem
{
EquipmentID = 61,
Description = "baseball glove"
};
r.EquipmentItems.Add(item2);
await r.CommitSave();
var getItems = await r.GetEquipmentItems();
var convertedList = (List <EquipmentItem>)getItems;
Assert.Equal("golf club", convertedList[0].Description);
Assert.Equal("baseball glove", convertedList[1].Description);
}
}
public async void TestForGetEquipmentRequestById()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3GetRequestById")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
var request = new EquipmentRequest
{
RequestID = Guid.NewGuid(),
TeamID = Guid.NewGuid(),
UserID = "fred",
RequestDate = DateTime.Now,
Message = "i need equipment now!",
ItemId = 53,
Status = "Approved"
};
r.EquipmentRequests.Add(request);
await r.CommitSave();
var getRequest = await r.GetEquipmentRequestById(request.RequestID);
Assert.Equal("fred", getRequest.UserID);
Assert.Equal("i need equipment now!", getRequest.Message);
Assert.Equal(53, getRequest.ItemId);
Assert.Equal("Approved", getRequest.Status);
}
}
public async void TestForGetEquipmentItemById()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3GetItemById")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
var item = new EquipmentItem
{
EquipmentID = 43,
Description = "golf club"
};
r.EquipmentItems.Add(item);
await r.CommitSave();
var getItem = await r.GetEquipmentItemById(item.EquipmentID);
Assert.Equal("golf club", getItem.Description);
}
}
public CreateModel(EquipmentContext context,
UserManager <User> userManager,
IAuthorizationService authorizationService,
IUsageRecordService usageRecordService)
: base(context, userManager, authorizationService)
{
_usageRecordService = usageRecordService;
}
public CreateModel(MalfunctionContext context,
IAuthorizationService authorizationService,
UserManager <User> userManager,
EquipmentContext equipmentContext)
: base(context, authorizationService, userManager)
{
_equipmentContext = equipmentContext;
}
public BasePageModel(
EquipmentContext context,
UserManager <User> userManager,
IAuthorizationService authorizationService)
{
_context = context;
_userManager = userManager;
_authorizationService = authorizationService;
}
public EditModel(EquipmentContext context,
IWebHostEnvironment env,
UserManager <User> userManager,
IAuthorizationService authorizationService,
IConfiguration config)
: base(context, userManager, authorizationService)
{
_env = env;
_fileSizeLimit = config.GetValue <long>("FileSizeLimit");
_uploadFilePath = Path.Combine(config.GetValue <string>("StoredFilesPath"), "InstrumentAcceptance");
Directory.CreateDirectory(_uploadFilePath);
}
public async void TestForGetEquipmentRequests()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3ControllerGetEquipmentRequests")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
Logic l = new Logic(r, new NullLogger <Repo>());
Mapper m = new Mapper();
EquipmentController controller = new EquipmentController(l, m);
var request = new EquipmentRequest
{
RequestID = Guid.NewGuid(),
TeamID = Guid.NewGuid(),
UserID = "fred",
RequestDate = DateTime.Now,
Message = "i need equipment now!",
ItemId = 53,
Status = "Approved"
};
r.EquipmentRequests.Add(request);
var request2 = new EquipmentRequest
{
RequestID = Guid.NewGuid(),
TeamID = Guid.NewGuid(),
UserID = "tom",
RequestDate = DateTime.Now,
Message = "broken helmet",
ItemId = 27,
Status = "Pending"
};
r.EquipmentRequests.Add(request2);
await r.CommitSave();
//var getRequests = await controller.GetEquipmentRequests();
//var convertedList = (List<EquipmentRequest>)getRequests;
//Assert.Equal("fred", convertedList[0].UserID);
//Assert.Equal("i need equipment now!", convertedList[0].Message);
//Assert.Equal(53, convertedList[0].ItemId);
//Assert.Equal("Approved", convertedList[0].Status);
//Assert.Equal("tom", convertedList[1].UserID);
//Assert.Equal("broken helmet", convertedList[1].Message);
//Assert.Equal(27, convertedList[1].ItemId);
//Assert.Equal("Pending", convertedList[1].Status);
}
}
public IndexModel(EquipmentContext context,
UserManager <User> userManager,
IAuthorizationService authorizationService,
IUsageRecordService usageRecordService,
IMaintenanceRecordService maintenanceRecordService,
IUserResolverService userResolverService,
IAuditTrailService auditTrailService)
: base(context, userManager, authorizationService)
{
_usageRecordService = usageRecordService;
_maintenanceRecordService = maintenanceRecordService;
_userResolverService = userResolverService;
_auditTrailService = auditTrailService;
}
public void PopulateProjectDropDownList(EquipmentContext _context)
{
var isAdmin = User.IsInRole(Constants.ManagerRole) || User.IsInRole(Constants.DirectorRole);
var userGroup = _userManager.GetUserAsync(User).Result?.Group;
if (isAdmin || userGroup == null)
{
ProjectsSelectList = new SelectList(_context.Projects, "Name", "Name");
}
else
{
ProjectsSelectList = new SelectList(_context.Projects.Include(p => p.Group).Where(p => p.Group.Name == userGroup), "Name", "Name");
}
}
/// <summary>
/// Default constructor.
/// </summary>
public Manager()
{
_equipmentContext = new EquipmentContext();
_stockContext = new StockContext();
_positionRepos = new GenericRepositoryEF <Position>(_equipmentContext);
_journalRepos = new GenericRepositoryEF <JournalEntry>(_equipmentContext);
_journalEntryCategoryRepos = new GenericRepositoryEF <JournalEntryCategory>(_equipmentContext);
_positionStatusBitInfoRepos = new GenericRepositoryEF <PositionStatusBitInfo>(_equipmentContext);
_stockItemsRepos = new GenericRepositoryAccess <StockItem>(_stockContext);
PositionReposProxy = new RepositoryProxy <Position>(_positionRepos);
JournalReposProxy = new RepositoryProxy <JournalEntry>(_journalRepos);
JournalEntryCategoryReposProxy = new RepositoryProxy <JournalEntryCategory>(_journalEntryCategoryRepos);
PositionStatusBitInfoReposProxy = new RepositoryProxy <PositionStatusBitInfo>(_positionStatusBitInfoRepos);
StockItemsReposProxy = new RepositoryProxy <StockItem>(_stockItemsRepos);
PositionStatusBitsInfo = _positionStatusBitInfoRepos.Get();
}
public async void TestForEditEquipmentRequest()
{
var options = new DbContextOptionsBuilder <EquipmentContext>()
.UseInMemoryDatabase(databaseName: "p3ControllerEditRequest")
.Options;
using (var context = new EquipmentContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
Logic l = new Logic(r, new NullLogger <Repo>());
Mapper m = new Mapper();
EquipmentController controller = new EquipmentController(l, m);
var request = new EquipmentRequest
{
RequestID = Guid.NewGuid(),
TeamID = Guid.NewGuid(),
UserID = "fred",
RequestDate = DateTime.Now,
Message = "i need equipment now!",
ItemId = 53,
Status = "Approved"
};
r.EquipmentRequests.Add(request);
await r.CommitSave();
var editRequestDto = new EditEquipmentRequestDto
{
Status = "Pending"
};
var editRequest = await controller.EditEquipmentRequest(request.RequestID, editRequestDto);
Assert.Equal("fred", editRequest.Value.UserID);
Assert.Equal("i need equipment now!", editRequest.Value.Message);
Assert.Equal(53, editRequest.Value.ItemId);
Assert.Equal("Pending", editRequest.Value.Status);
}
}
private void Hook()
{
if (hooked)
{
return;
}
equipContext = new EquipmentContext(settings);
repairContext = new RepairContext(settings);
if (hooked)
{
TreeHooks.Instance.RemoveHook("TreeStart", root);
}
root = Agil.CreateBehavior(equipContext, repairContext);
TreeHooks.Instance.InsertHook("TreeStart", 0, root);
Logger.AgilMessage("Hooked.");
hooked = true;
timer.Stop();
timer.Start();
}
public EditModel(EquipmentContext context, UserManager <User> userManager, RoleManager <IdentityRole> roleManager)
{
_context = context;
_userManager = userManager;
_roleManager = roleManager;
}
public EditModel(EquipmentContext context)
{
_context = context;
}
public IndexModel(EquipmentContext context, MalfunctionContext malfunctionContext)
{
_equipmentContext = context;
_malfunctionContext = malfunctionContext;
}
public CreateModel(EquipmentContext context)
{
_context = context;
}
public DeleteModel(EquipmentContext context)
{
_context = context;
}
public EquipmentController(EquipmentContext context)
{
_context = context;
}
public EquipmentRepository(EquipmentContext context, IStringLocalizer <SharedResources> localizer)
{
_context = context;
_localizer = localizer;
}
public EquipmentBrandRepository(EquipmentContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public IndexModel(EquipmentContext context)
{
_context = context;
}
public RepositoryBase(EquipmentContext equipmentContext)
{
_equipmentContext = equipmentContext;
}
public DetailsModel(EquipmentContext context)
{
_context = context;
}
public BasketManager(ISessionManager session, EquipmentContext db)
{
this.session = session;
this.db = db;
}
public CrossCountrySkiCategoryRepository(EquipmentContext equipmentContext) :
base(equipmentContext)
{
}
public AuditTrailService(EquipmentContext context)
{
_context = context;
}
public CreateModel(EquipmentContext context,
UserManager <User> userManager,
IAuthorizationService authorizationService)
: base(context, userManager, authorizationService)
{
}
public InvoiceController(EquipmentContext context, ICartService cartService)
{
_context = context;
_cartService = cartService;
}
