private void InitFilter()
{
Filter = new UnitFilter();
ComplexFilterParams = new UnitFilterParams();
var unitTypeRepository = new UnitTypeRepository();
FilterUnitTypeList = unitTypeRepository.GetAll(type => type.TypeName);
var repository = Repository as UnitRepository;
if (repository != null)
{
FilterManufactureList = repository.GetManufactureList();
FilterModelNameList = repository.GetModelList();
}
var ownerRepository = new OwnerRepository();
FilterOwnerList = ownerRepository.GetAll(owner => owner.Name.DisplayName);
var statusRepository = new StatusRepository();
FilterStatusList = statusRepository.GetAll(x => x.StatusType);
}
public NotificationService(ApplicationDbContext context)
{
this.context = context;
notificationRepository = new NotificationRepository(context);
notificationTypeRepository = new NotificationTypeRepository(context);
statusRepository = new StatusRepository(context);
}
public void Save_ChangeStatus_Valid()
{
// Arrange - Initialize
var status = new StatusRepository(context).FindById(14);
disbursementRepository.Save(new Disbursement()
{
DisbursementId = "DDREPOTEST",
CreatedDateTime = DateTime.Now,
});
disbursementDetailRepository.Save(new DisbursementDetail()
{
DisbursementId = "DDREPOTEST",
Status = status,
ItemCode = "E030",
});
// Arrange - Get Existing
var expected = disbursementDetailRepository.FindById("DDREPOTEST", "E030");
expected.Status = new StatusRepository(context).FindById(15);
// Act
var result = disbursementDetailRepository.Save(expected);
// Assert
Assert.AreEqual(expected.Status, result.Status);
}
private async void MoveCar(string status_Name)
{
List <Status> statuses = Task.FromResult <List <Status> >(await StatusRepository.GetStatuses()).Result;
if (status_Name == statuses[0].Name)
{
}
switch (status_Name)
{
case "Aangevraagd":
Car = HorizontalAlignment.Left;
break;
case "Onderweg":
Car = HorizontalAlignment.Center;
break;
case "Toegekomen":
Car = HorizontalAlignment.Right;
break;
case "Done":
Car = HorizontalAlignment.Right;
break;
default:
break;
}
RaiseAll();
}
public void Save_ChangeStatus_Valid()
{
// Arrange - Initialize
var status = new StatusRepository(context).FindById(14);
purchaseOrderRepository.Save(new PurchaseOrder()
{
PurchaseOrderNo = "PODREPOTEST",
CreatedDateTime = DateTime.Now,
});
purchaseOrderDetailRepository.Save(new PurchaseOrderDetail()
{
PurchaseOrderNo = "PODREPOTEST",
Status = status,
ItemCode = "E030",
});
// Arrange - Get Existing
var expected = purchaseOrderDetailRepository.FindById("PODREPOTEST", "E030");
expected.Status = new StatusRepository(context).FindById(15);
// Act
var result = purchaseOrderDetailRepository.Save(expected);
// Assert
Assert.AreEqual(expected.Status, result.Status);
}
public UnitOfWork(bool test = false)
{
if (!test && !Test)
{
AccountTypes = new AccountTypeRepository(new AccountTypeOracleContext());
Employees = new EmployeeRepository(new EmployeeOracleContext());
AttachedTracks = new AttachedTrackRepository(new AttachedTrackOracleContext());
Routes = new RouteRepository(new RouteOracleContext());
Sectors = new SectorRepository(new SectorOracleContext());
Statuses = new StatusRepository(new StatusOracleContext());
Tracks = new TrackRepository(new TrackOracleContext());
//TrackRoutes = new TrackRouteRepository(new TrackRouteOracleContext());
Trams = new TramRepository(new TramOracleContext());
TramRoutes = new TramRouteRepository(new TramRouteOracleContext());
Tasks = new TaskRepository(new TaskOracleContext());
}
else
{
AccountTypes = new AccountTypeRepository(new AccountTypeTestContext());
Employees = new EmployeeRepository(new EmployeeTestContext());
Tracks = new TrackRepository(new TrackTestContext());
Sectors = new SectorRepository(new SectorTestContext());
Trams = new TramRepository(new TramTestContext());
Routes = new RouteRepository(new RouteTestContext());
AttachedTracks = new AttachedTrackRepository(new AttachedTrackTestContext());
TramRoutes = new TramRouteRepository(new TramRouteTestContext());
TrackRoutes = new TrackRouteRepository(new TrackRouteTestContext());
TramStatuses = new TramStatusRepository(new TramStatusTestContext());
}
}
public int GetStatusId(int id)
{
StatusRepository sr = new StatusRepository(ConstantUtil.MyConnectionString);
ViewBag.Status = sr.GetById(id);
return(ViewBag.Status);
}
public ActionResult Details(int id)
{
var model = new ProjectFormModel();
var project = ProjectRepository.ProjectFetch(id);
model.Title = string.Format("Project {0}", project.Name);
model.Project = project;
model.Notes = NoteRepository.NoteFetchInfoList(id, SourceType.Project);
model.Attachments = AttachmentRepository.AttachmentFetchInfoList(
model.Notes.Select(row => row.NoteId).Distinct().ToArray(), SourceType.Note);
model.Sprints = SprintRepository.SprintFetchInfoList(project);
model.Statuses = StatusRepository.StatusFetchInfoList(id);
model.Stories = StoryRepository.StoryFetchInfoList(project, false);
model.Users = ProjectUserRepository.ProjectUserFetchInfoList(id);
model.TimelineListModel = new TimelineListModel
{
Timelines = TimelineRepository.TimelineFetchInfoList(project),
SourceId = project.SourceId,
SourceTypeId = (int)project.SourceType
};
model.Actions.Add("Edit this project", Url.Action("Edit", new { id }), "primary");
model.Actions.Add("Add a story", Url.Action("Create", "Story", new { projectId = id }));
model.Actions.Add("Add a sprint", Url.Action("Create", "Sprint", new { projectId = id }));
model.Actions.Add("Add an email", string.Empty);
model.Actions.Add("Add a note", Url.Action("Create", "Note", new { sourceId = id, sourceTypeId = (int)SourceType.Project }));
model.Actions.Add("Add a collaborator", Url.Action("Create", "ProjectUser", new { projectId = id }));
model.Actions.Add("Add a status", Url.Action("Create", "Status", new { projectId = id }));
return(this.View(model));
}
public PedidosController(IConfiguration configuration)
{
PedidosRepository = new PedidosRepository(configuration);
ClientesRepository = new ClientesRepository(configuration);
StatusRepository = new StatusRepository(configuration);
FormapagamentosRepository = new FormapagamentosRepository(configuration);
}
private void MergeList(List originalList, ListRequest List)
{
originalList.Customer = List.Customer;
originalList.Consortium = this.ConsortiumRepository.GetById(List.ConsortiumId);
originalList.OpenDate = List.OpenDate;
originalList.Coments = List.Coments;
originalList.Tasks = new List <TaskList>();
foreach (var task in List.Tasks)
{
if (task.Id == 0)
{
originalList.Tasks.Add(
new TaskList()
{
List = originalList,
Id = task.Id,
Description = task.Description,
Result = TaskResultRepository.GetById(task.ResultId),
Coments = task.Coments,
Status = StatusRepository.GetById(task.StatusId)
});
}
else
{
originalList.Tasks.Where(x => x.Id.Equals(task.Id)).FirstOrDefault().Description = task.Description;
originalList.Tasks.Where(x => x.Id.Equals(task.Id)).FirstOrDefault().Coments = task.Coments;
originalList.Tasks.Where(x => x.Id.Equals(task.Id)).FirstOrDefault().Result = TaskResultRepository.GetById(task.ResultId);
originalList.Tasks.Where(x => x.Id.Equals(task.Id)).FirstOrDefault().Status = StatusRepository.GetById(task.StatusId);
}
}
}
public static void Main(string[] args)
{
ITransitionRepository transitions = new TransitionRepository();
IStatusRepository statuses = new StatusRepository();
ISubtypeRepository subtypes = new SubtypeRepository();
IStatusService service = new StatusService(transitions, statuses, subtypes);
var initialDefaultStatuses = service.GetInitialStatuses(SubtypeRepository.DefaultSubtype);
var initialValidationStatuses = service.GetInitialStatuses(SubtypeRepository.ValidationSubtype);
Console.WriteLine("------ Initial Default Statuses ------");
foreach (var defaultStatus in initialDefaultStatuses)
{
Console.WriteLine(defaultStatus);
}
Console.WriteLine("------ Initial Validation Statuses ------");
foreach (var validationStatus in initialValidationStatuses)
{
Console.WriteLine(validationStatus);
}
Console.ReadLine();
}
public ActionResult InvestmentByRegionExport(InvestmentByRegionViewModel model)
{
if (ModelState.IsValid)
{
try
{
using (var ms = new MemoryStream())
{
model.InvestmentByRegions = ReportRepository.GetInvestmentByRegion(model);
model.Regions = model.InvestmentByRegions.Select(s => s.Region).Distinct().OrderBy(c => c).ToList();
model.Sectors = StatusRepository.GetStatusByGroup("Sector");
var exporterService = new ExcelExportService();
var workbook = exporterService.ExportByRegion(model);
//Write the Workbook to a memory stream
workbook.Write(ms);
var fileName = "Foreign investment Chart (" + DateTime.Now.ToString("ddMMyyyy-HHmmss") + ")." + exporterService.Extension;
Response.AddHeader("Content-Disposition", "attachment; filename=" + fileName);
//Return the result to the end user
return(File(ms.ToArray(), exporterService.MIME));
//Suggested file name in the "Save as" dialog which will be displayed to the end user
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "Error in - ExportToExcel :" + ex.Message);
return(View("InvestmentByCountryExport"));
}
}
return(View("InvestmentByCountryExport"));
}
public void TestInitialize()
{
context = new ApplicationDbContext();
statusRepository = new StatusRepository(context);
saRepository = new StockAdjustmentRepository(context);
userRepository = new UserRepository(context);
//Create a draft stockadjustment
StockAdjustment sa1 = new StockAdjustment();
sa1.StockAdjustmentId = "he01";
sa1.CreatedDateTime = DateTime.Now;
sa1.Status = statusRepository.FindById(3);
sa1.CreatedBy = userRepository.FindByEmail("*****@*****.**");
sa1.ApprovedBySupervisor = userRepository.FindByEmail("*****@*****.**");
StockAdjustmentDetail s1 = new StockAdjustmentDetail();
s1.StockAdjustmentId = "he01";
s1.ItemCode = "C002";
s1.OriginalQuantity = 10;
s1.AfterQuantity = 20;
StockAdjustmentDetail s2 = new StockAdjustmentDetail();
s2.StockAdjustmentId = "he01";
s2.ItemCode = "C003";
s2.OriginalQuantity = 20;
s2.AfterQuantity = 30;
List <StockAdjustmentDetail> list = new List <StockAdjustmentDetail>();
list.Add(s1);
list.Add(s2);
sa1.StockAdjustmentDetails = list;
saRepository.Save(sa1);
}
public async Task <List <StopStatus> > List()
{
var oStatusRepository = new StatusRepository();
IDataReader oDataReader = null;
try
{
oDataReader = await oStatusRepository.List();
}
catch (Exception)
{
throw;
}
var lstStatuses = new List <StopStatus>();
while (oDataReader.Read())
{
var oStatus = new StopStatus(oDataReader);
lstStatuses.Add(oStatus);
}
oDataReader.Close();
return(lstStatuses);
}
public HttpResponseMessage Get()
{
var requestors = StatusRepository.GetAllStatus();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, requestors);
return(response);
}
public ActionResult <string> GetMailBody()
{
var repo = new StatusRepository();
var result = repo.GetMailBody().Result;
return(result);
}
public ActionResult <bool> SendMail(string htmlString)
{
var repo = new StatusRepository();
repo.SendMail(htmlString);
return(true);
}
public IHttpActionResult ListStatus()
{
var repository = new StatusRepository();
var statuses = repository.ListStatus();
return(Ok(statuses.ToModel()));
}
public void TestInitialize()
{
context = new ApplicationDbContext();
deliveryOrderService = new DeliveryOrderService(context);
deliveryOrderRepository = new DeliveryOrderRepository(context);
purchaseOrderRepository = new PurchaseOrderRepository(context);
inventoryRepository = new InventoryRepository(context);
itemRepository = new ItemRepository(context);
deliveryOrderDetailRepository = new DeliveryOrderDetailRepository(context);
stockMovementRepository = new StockMovementRepository(context);
statusRepository = new StatusRepository(context);
//create test PO object and save to db
PurchaseOrder PO = new PurchaseOrder()
{
PurchaseOrderNo = "VALLI",
CreatedDateTime = DateTime.Now,
Supplier = context.Supplier.Where(x => x.SupplierCode == "CHEP").First()
};
purchaseOrderRepository.Save(PO);
// create test DO object and save to db
DeliveryOrder DO = new DeliveryOrder()
{
DeliveryOrderNo = "DOTEST",
PurchaseOrder = PO,
CreatedDateTime = DateTime.Now,
Supplier = context.Supplier.Where(x => x.SupplierCode == "CHEP").First()
};
deliveryOrderRepository.Save(DO);
}
public CategoryService()
{
_customerRepository = new CustomerRepository();
_meetingRoomRepository = new MeetingRoomRepository();
_statusRepository = new StatusRepository();
_applicationLoggingRepository = new ApplicationLoggingRepository();
_noticeRepository = new NoticeRepository();
}
public StatusRepositoryTests()
{
var credentialsFactory = Substitute.For <ITwitterCredentialsFactory>();
var credentials = TestUtils.GetCredentials();
credentialsFactory.Create().Returns(credentials);
this.statusRepository = new StatusRepository(credentialsFactory);
}
public static Status StatusAdd()
{
var status = StatusTestHelper.StatusNew();
status = StatusRepository.StatusSave(status);
return(status);
}
//PurchaseOrderService purchaseOrderService;
public ItemService(ApplicationDbContext context)
{
this.context = context;
itemRepository = new ItemRepository(context);
statusRepository = new StatusRepository(context);
inventoryRepository = new InventoryRepository(context);
// purchaseOrderService = new PurchaseOrderService(context);
}
private void InitViewModel(Status status)
{
_statusRepository = new StatusRepository();
Status = status;
SaveCommand = new RelayCommand(x => SaveMethod());
CloseCommand = new RelayCommand(x => CloseMethod());
}
public ActionResult Delete(int id, FormCollection collection)
{
var status = StatusRepository.StatusFetch(id);
StatusRepository.StatusDelete(id);
return(this.RedirectToAction("Details", "Project", new { id = status.ProjectId }));
}
private void InitViewModel()
{
Repository = new StatusRepository();
AddCommand = new RelayCommand(x => AddMethod());
EditCommand = new RelayCommand(x => EditMethod());
DeleteCommand = new RelayCommand(x => DeleteMethod());
}
public App(string dbPath)
{
InitializeComponent();
StatusRepository = new StatusRepository(dbPath);
ResumeRepository = new ResumeRepository(dbPath);
DifficultySettings = SettingsData.CreateDifficultySettings();
MainPage = new NavigationPage(new HomePage());
}
protected ITestDriveService GetService(ApplicationDbContext dbContext, UserManager <User> userManager)
{
var testDriveRepository = new TestDriveRepository(dbContext);
var statusRepository = new StatusRepository(dbContext);
var carRepository = new CarRepository(dbContext);
var servie = new TestDriveService(testDriveRepository, statusRepository, carRepository, userManager);
return(servie);
}
public void AddReturnsId()
{
var repository = new StatusRepository(dbFactory, personRepository);
var response = repository.Add(new Status());
Assert.IsNotNull(response);
Assert.AreEqual(response.Id, 1);
}
public void Status_Fetch_Info_List()
{
StatusTestHelper.StatusAdd();
StatusTestHelper.StatusAdd();
var statuss = StatusRepository.StatusFetchInfoList(new StatusDataCriteria());
Assert.IsTrue(statuss.Count() > 1, "Row returned should be greater than one");
}
public static bool IsBorrowed(copy c)
{
if (StatusRepository.GetStatusByISBN(c.ISBN).statusid != 2)
{
return(true);
}
return(false);
}
public bool ChangeUserStatus(ChatState status, int userId)
{
bool flag = false;
using (StatusRepository statusRepo = new StatusRepository(new ChatDBDataContext()))
{
tbl_ChatUserStatus statusRec = statusRepo.Get(userId.ToString());
statusRec.Status = (int)status;
statusRepo.Save();
if (statusRepo.Get(userId.ToString()).Status.Equals((int)status))
flag = true;
}
return flag;
}
public void AddPersists()
{
var repository = new StatusRepository(dbFactory, personRepository);
repository.Add(new Status { Name = "Test Item" });
dbFactory.Run(db =>
{
var response = db.Select<Status>();
Assert.AreEqual(response.Count, 1);
Assert.AreEqual(response[0].Name, "Test Item");
});
}
public void DeleteFails()
{
dbFactory.Run(db => db.Insert(new Status { Id = 1, Name = "Test Item" }));
var repository = new StatusRepository(dbFactory, personRepository);
repository.Delete(2);
dbFactory.Run(db =>
{
var response = db.Select<Status>();
Assert.AreEqual(response.Count, 1);
Assert.AreEqual(response[0].Name, "Test Item");
});
}
public void RegisterStatus(ChatState status, int loginId)
{
using (StatusRepository statusRepo = new StatusRepository(new ChatDBDataContext()))
{
statusRepo.Create(new tbl_ChatUserStatus()
{
Status = (int)status, UserID = loginId
});
statusRepo.Save();
}
}
public static ICRUDRepository<Status> GetStatusRepository()
{
if(StatusRepo == null)
{
StatusRepo = new StatusRepository();
}
return StatusRepo;
}
public void UpdateIsSingular()
{
dbFactory.Run(db =>
{
db.Insert(new Status { Id = 1, Name = "Test Item" });
db.Insert(new Status { Id = 2, Name = "Test Item 2" });
});
var repository = new StatusRepository(dbFactory, personRepository);
repository.Update(new Status { Id = 1, Name = "Test Edit" });
dbFactory.Run(db =>
{
var response = db.Select<Status>();
Assert.AreEqual(response.Count, 2);
Assert.AreEqual(response.Single(x => x.Id == 1).Name, "Test Edit");
Assert.AreEqual(response.Single(x => x.Id == 2).Name, "Test Item 2");
});
}
public void StatusRepository()
{
Mock<IDbSetFactory> factory = new Mock<IDbSetFactory>();
Mock<DbSet<Status>> dbSet = new Mock<DbSet<Status>>();
factory.Setup(m => m.CreateDbSet<Status>()).Returns(dbSet.Object);
StatusRepository repo = new StatusRepository(factory.Object);
var Status = new Status();
var sequence = new MockSequence();
dbSet.InSequence(sequence).Setup(e => e.Add(Status));
dbSet.InSequence(sequence).Setup(e => e.Find(Status.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(Status.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(Status.Id));
repo.Create(Status);
repo.Get(Status.Id);
repo.Update(Status);
repo.Delete(Status.Id);
}
public void GetAllReturnsEmpty()
{
var repository = new StatusRepository(dbFactory, personRepository);
var response = repository.GetAll();
Assert.IsNotNull(response);
Assert.AreEqual(response.Count, 0);
}
public void GetAllReturnsItems()
{
dbFactory.Run(db =>
{
db.Insert(new Status { Id = 1, Name = "Test Item" });
db.Insert(new Status { Id = 2, Name = "Test Item 2" });
});
var repository = new StatusRepository(dbFactory, personRepository);
var response = repository.GetAll();
Assert.IsNotNull(response);
Assert.AreEqual(response.Count, 2);
Assert.AreEqual(response.Single(x => x.Id == 1).Name, "Test Item");
Assert.AreEqual(response.Single(x => x.Id == 2).Name, "Test Item 2");
}
public void GetByIdReturnsNull()
{
dbFactory.Run(db => db.Insert(new Status { Id = 1, Name = "Test Item" }));
var repository = new StatusRepository(dbFactory, personRepository);
var response = repository.GetById(2);
Assert.IsNull(response);
}
public void MoveShiftsIncreasing2()
{
dbFactory.Run(db =>
{
db.Insert(new Status { Id = 1, Name = "Item 1", Order = 1 });
db.Insert(new Status { Id = 2, Name = "Item 2", Order = 2 });
db.Insert(new Status { Id = 3, Name = "Item 3", Order = 3 });
});
var repository = new StatusRepository(dbFactory, personRepository);
repository.Move(1, -2);
dbFactory.Run(db =>
{
var response = db.Select<Status>();
Assert.AreEqual(response.Count, 3);
Assert.AreEqual(response.Single(x => x.Id == 1).Order, 3);
Assert.AreEqual(response.Single(x => x.Id == 2).Order, 1);
Assert.AreEqual(response.Single(x => x.Id == 3).Order, 2);
});
}
//
// GET: /Admin/
private void DropDownInit()
{
StatusRepository statusRep = new StatusRepository();
List<t_status> statusList = statusRep.Get().ToList();
ViewBag.status = new SelectList(statusList, "statusID", "status", null);
}
