public void FillData()
{
BasicRepository _basic = new BasicRepository();
BasicContants.StoredProcedure = "GetGender";
Genders = _basic.Get();
GenderList = Genders.ToGenderSelectListItems(GenderID);
BasicContants.StoredProcedure = "GetStudentType";
Students = _basic.Get();
StudentList = Students.ToStudentTypeSelectListItems(StudentTypeID);
SectionsRepository _section = new SectionsRepository();
BasicContants.StoredProcedure = "GetFullSectionName";
Sections = _section.Get();
SectionList = Sections.ToSectionSelectListItems(SectionID);
ParentRepository _parent = new ParentRepository();
Parents = _parent.Get();
ParentList = Parents.ToParentSelectListItems(ParentID);
TransportRepository _transport = new TransportRepository();
Transports = _transport.Get();
TransportList = Transports.ToTransportSelectListItems(TransportID);
}
public MedRegistratorPatientService(int id)
{
_repository = repository;
_patient = copyPatient(_repository.getPatientFullDatabase(id));
_newPatient = false;
_succesfullPatientInfoSaving = false;
}
public void UpdateLogin()
{
Login login = new Login()
{
Active = true,
Email = "*****@*****.**",
FirstName = "Jacobo",
LastName = "Marcos Perchin",
UserLogin = "******",
Password = "******",
PasswordExpirationDate = DateTime.UtcNow.AddMonths(6)
};
login = this.BasicRepository.Save(login);
ThreadIdentity.SetCurrentThreadIdentity("Update Test Identity");
login.Email = "*****@*****.**";
login.Password = "******";
login.PasswordExpirationDate = DateTime.UtcNow.AddMonths(12);
DateTime beforeUpdate = DateTime.UtcNow;
BasicRepository.Update(login);
Login loginUpdated = RefreshEntityFromDatabase(login.Id.Value);
Assert.AreEqual(login.Active, loginUpdated.Active);
Assert.AreEqual(login.Email, loginUpdated.Email);
Assert.AreEqual(login.FirstName, loginUpdated.FirstName);
Assert.AreEqual(login.LastName, loginUpdated.LastName);
Assert.AreEqual(login.UserLogin, loginUpdated.UserLogin);
Assert.AreEqual(login.Password, loginUpdated.Password);
Assert.AreEqual(login.PasswordExpirationDate, loginUpdated.PasswordExpirationDate);
VerifyAuditInfoAfterUpdate(loginUpdated, beforeUpdate, "Update Test Identity");
}
/// <summary>
/// Configure the data system to map requests for User type onto TUser via Identity mechanisms
/// </summary>
public virtual void InitialiseDataApi()
{
ContentTypeHierarchy.RegisterType(typeof(User));
ContentTypeHierarchy.RegisterType(typeof(TUser));
var sys = LyniconSystem.Instance;
var extender = LyniconSystem.Instance.Extender;
extender.RegisterForExtension(typeof(User));
//extender.RegisterExtensionType(typeof(LyniconIdentityUser));
var efDSFactory = new EFDataSourceFactory <TContext>(sys);
var appDbRepository = new BasicRepository(sys, efDSFactory);
efDSFactory.DbSetSelectors[typeof(TUser)] = db => db.Users.AsNoTracking();
efDSFactory.ContextLifetimeMode = ContextLifetimeMode.PerCall;
// We DON'T want to register TUser with CompositeTypeManager
var basicCollator = new BasicCollator(sys);
Collator.Instance.Register(typeof(TUser), new BasicCollator(sys));
Repository.Instance.Register(typeof(TUser), appDbRepository);
// override existing collator registration for User
var identityAdaptorCollator = new IdentityAdaptorCollator <TUser, TUserManager>(sys);
Collator.Instance.Register(typeof(User), identityAdaptorCollator);
//Repository.Instance.Register(typeof(User), new BasicRepository());
}
private void DisplayData()
{
var repository = new BasicRepository();
ctlBasicList.DataSource = repository.GetAll();
ctlBasicList.DataBind();
}
/// <summary>
/// 获取编辑页面下拉列表
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文</param>
/// <returns></returns>
public async Task <StudentEditViewModel> GetDropDownListAsync(StudentEditViewModel webModel, ApplicationDbContext context)
{
//Get Source Data
//
var departmentList = await BasicRepository.GetDepartmentList(context);
var majorclassList = await BasicRepository.GetMajorClassList(context);
if (departmentList != null && departmentList.Any())
{
webModel.DepartmentList = departmentList.Select(item => new DepartmentDropDown
{
Id = item.Id.ToString(),
Name = item.Name
}).ToList();
}
if (majorclassList != null && majorclassList.Any())
{
webModel.MajorClassList = majorclassList.Select(item => new MajorClassDropDown
{
Id = item.Id.ToString(),
Name = item.Name
}).ToList();
}
return(webModel);
}
public ExtendedRolesProvider()
{
_roleFeaturesRepository = new RoleFeaturesRepository(new DatabaseFactory());
_featuresRepository = new FeaturesRepository(new DatabaseFactory());
_basicRepository = new BasicRepository(new DatabaseFactory());
_employeeRepository = new EmployeeRepository(new DatabaseFactory());
_driverRepository = new DriverRepository(new DatabaseFactory());
}
public CredentialsViewModel()
{
BasicRepository _basic = new BasicRepository();
BasicContants.StoredProcedure = "GetUserType";
UserTypes = _basic.Get();
UserTypeList = UserTypes.ToUserTypeSelectListItems(UserTypeID);
}
public MedRegistratorPatientService()
{
_repository = repository;
_patient = new patientFull();
_patient.surveys = new List <patientFull.Survey>();
_newPatient = true;
_succesfullPatientInfoSaving = false;
}
public RoleManageController(RoleRepository roleRepository
, UsersRoleRepository usersRoleRepository
, BasicRepository basicRepository
, UsersAccessRepository usersAccessRepository) : base(usersAccessRepository)
{
_roleRepository = roleRepository;
_usersRoleRepository = usersRoleRepository;
_basicRepository = basicRepository;
_usersAccessRepository = usersAccessRepository;
}
// this injection is fine since the design hides this behind internal
internal PagingFetchBuilder(BasicRepository repository, FetchParameters <TModel> fetchParameters)
{
if (fetchParameters == null)
{
throw new System.ArgumentNullException(nameof(fetchParameters));
}
this.fetchParameters = new FetchPagingParameters <TModel>(fetchParameters);
this.repository = repository;
}
public IRepository <T> Repository <T>() where T : EntityBase
{
if (repositories.Keys.Contains(typeof(T)) == true)
{
return(repositories[typeof(T)] as IRepository <T>);
}
IRepository <T> repo = new BasicRepository <T>(_dbContext);
repositories.Add(typeof(T), repo);
return(repo);
}
public EntityFrameworkUnitOfWork(LMSDbContext context, IRepositoryAsync <User> usersRepo)
{
dbContext = context;
TaskTypes = new BasicRepository <TaskType>(context);
Categories = new BasicRepository <Category>(context);
Tasks = new TaskRepository(context);
TestTemplates = new TestTemplateRepository(context);
Tests = new TestRepository(context);
TestSessions = new TestSessionRepository(context);
Examinee = new ExamineeRepositoty(context);
Answers = new AnswerRepository(context);
UserRepository = usersRepo;
}
public TOTUnitOfWork(TOTDBContext context)
{
dbContext = context;
TimeOffRequests = new TimeOffRequestRepository(context);
TimeOffTypes = new BasicRepository <TimeOffType>(context);
EmployeePositions = new BasicRepository <EmployeePosition>(context);
RequestApprovals = new TimeOffRequestApprovalRepository(context);
RequestApprovalStatuses = new BasicRepository <TimeOffRequestApprovalStatuses>(context);
TimeOffPolicies = new TimeOffPolicyRepository(context);
TimeOffPolicyApprovers = new TimeOffPolicyApproversRepository(context);
EmployeePositionTimeOffPolicies = new EmployeePositionTimeOffPolicyRepository(context);
}
public EmployeeAccountModel()
{
BasicRepository _basic = new BasicRepository();
BasicContants.StoredProcedure = "GetAdminRoles";
Roles = _basic.Get();
RoleList = Roles.ToRoleSelectListItems(RoleID);
BasicContants.StoredProcedure = "GetGender";
Genders = _basic.Get();
GenderList = Genders.ToGenderSelectListItems(GenderID);
BasicContants.StoredProcedure = "GetCity";
Cities = _basic.Get();
CityList = Cities.ToCitySelectListItems(CityID);
BasicContants.StoredProcedure = "GetDesignation";
Designations = _basic.Get();
DesignationList = Designations.ToDesignationSelectListItems(DesignationID);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
//默认返回 json
GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings.Add(
new QueryStringMapping("datatype", "json", "application/json"));
//返回格式选择 datatype 可以替换为任何参数
GlobalConfiguration.Configuration.Formatters.XmlFormatter.MediaTypeMappings.Add(
new QueryStringMapping("datatype", "xml", "application/xml"));
new WebApplication().Start(System.Web.HttpContext.Current);
BasicRepository.UpdateDB();
LogRepository.UpdateDB();
}
/// <summary>
/// Configure the data system to map requests for User type onto TUser via Identity mechanisms
/// </summary>
public virtual void InitialiseDataApi()
{
ContentTypeHierarchy.RegisterType(typeof(TUser));
CompositeTypeManager.Instance.RegisterExtensionType(typeof(LyniconIdentityUser));
var efDSFactory = new EFDataSourceFactory <TContext>();
var appDbRepository = new BasicRepository(efDSFactory);
efDSFactory.DbSetSelectors[typeof(TUser)] = db => db.Users.Include(u => u.Roles);
efDSFactory.ContextLifetimeMode = ContextLifetimeMode.PerCall;
// We DON'T want to register TUser with CompositeTypeManager
Collator.Instance.Register(typeof(TUser), new BasicCollator(Repository.Instance));
Repository.Instance.Register(typeof(TUser), appDbRepository);
// override existing collator registration for User
var identityAdaptorCollator = new IdentityAdaptorCollator <TUser, TUserManager>(GetUserManager);
identityAdaptorCollator.Repository = Repository.Instance;
Collator.Instance.Register(typeof(User), identityAdaptorCollator);
}
/// <summary>
///删除学生信息
/// </summary>
/// <param name="id">学生编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> DeleteStudentAsync(long id, ApplicationDbContext context)
{
try
{
//Delete staff Data
await BasicRepository.DeleteStaffAsync(id, context);
//Add Operate Information
var operate = string.Format("删除学生数据，学生编号:{0}", id);
PSURepository.InsertRecordAsync("IdentityUser", "BasicDomain", "DeleteStudentAsync", operate, (short)PSURepository.OperateCode.Delete, id, context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("删除学生失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 更新用户个人信息
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> UpdateUserProfileAsync(ProfileViewModel webModel, ApplicationDbContext context)
{
try
{
//Update IdentityUser Data
BasicRepository.UpdateAsync(webModel, context);
//Add Operate Information
var operate = string.Format("修改管理员信息，管理员编号:{0}", webModel.Id);
PSURepository.InsertRecordAsync("IdentityUser", "BasicDomain", "UpdateUserProfileAsync", operate, (short)PSURepository.OperateCode.Update, Convert.ToInt64(webModel.Id), context);
var index = await context.SaveChangesAsync();
return(index == 2);
}
catch (Exception ex)
{
_logger.LogError("更新管理员信息失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 搜索学生信息
/// </summary>
/// <param name="webModel">列表页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <StudentViewModel> SearchStudentAsync(StudentViewModel webModel, ApplicationDbContext context)
{
try
{
//Source Data List
var list = await BasicRepository.GetListAsync(webModel, context);
//Return Data List
var dataList = new List <StudentData>();
if (list != null && list.Any())
{
foreach (var item in list)
{
var student = new StudentData
{
Id = item.Id.ToString(),
Name = item.Name,
Gender = item.Gender,
Account = item.Account,
Phone = item.Phone,
Department = item.Department,
MajorClass = item.MajorClass
};
dataList.Add(student);
}
}
webModel.StudentList = dataList;
webModel.Total = await BasicRepository.GetListCountAsync(webModel, context);
}
catch (Exception ex)
{
_logger.LogError("获取学生信息列表失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
public void DeleteLogin()
{
Login login = new Login()
{
Active = true,
Email = "*****@*****.**",
FirstName = "Jacobo",
LastName = "Marcos Perchin",
UserLogin = "******",
Password = "******",
PasswordExpirationDate = DateTime.UtcNow.AddMonths(6)
};
login = this.BasicRepository.Save(login);
ThreadIdentity.SetCurrentThreadIdentity("Delete Test Identity");
DateTime beforeUpdate = DateTime.UtcNow;
BasicRepository.Delete(login);
Login loginDeleted = RefreshEntityFromDatabase(login.Id.Value);
VerifyAuditInfoAfterDelete(loginDeleted, beforeUpdate, "Delete Test Identity");
}
/// <summary>
/// 新增学生信息
/// </summary>
/// <param name="webModel">编辑页视图Model</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <bool> InsertStudentAsync(StudentEditViewModel webModel, ApplicationDbContext context)
{
try
{
//Add the student Data
var model = await BasicRepository.InsertAsync(webModel, context);
if (model.Id == -1)
{
return(false);
}
//Make the transaction commit
var index = await context.SaveChangesAsync();
return(index == 1);
}
catch (Exception ex)
{
_logger.LogError("创建新职工失败：{0},\r\n内部错误详细信息:{1}", ex.Message, ex.InnerException.Message);
return(false);
}
}
/// <summary>
/// 获取用户个人信息
/// </summary>
/// <param name="id">用户编号</param>
/// <param name="context">数据库连接上下文对象</param>
/// <returns></returns>
public async Task <ProfileViewModel> GetUserProfileAsync(long id, ApplicationDbContext context)
{
var webModel = new ProfileViewModel();
try
{
var model = await BasicRepository.GetProfileAsync(id, context);
webModel.Id = model.Id.ToString();
webModel.Name = model.Name;
webModel.Address = model.Address;
webModel.Age = model.Age;
webModel.CreateTime = model.CreatedOn.ToString();
webModel.Email = model.Email;
webModel.Gender = model.Gender;
webModel.Phone = model.Phone;
webModel.Account = model.Account;
}
catch (Exception ex)
{
_logger.LogError("获取用户个人数据失败：{0},\r\n内部错误信息：{1}", ex.Message, ex.InnerException.Message);
}
return(webModel);
}
public void CoreTestSetup()
{
_subject = null;
Storage = Mocker.Resolve <BasicRepository <TModel> >();
}
public DoctorPatientService(int id)
{
_repository = repository;
_patient = copyPatient(_repository.getPatientFullDatabase(id));
}
public DoctorService()
{
_repository = repository;
}
public MainPageViewModel(INavigationService navigationService, BasicRepository basicRepository)
{
this.navigationService = navigationService;
this.basicRepository = basicRepository;
}
public MedRegistratorService()
{
_repository = repository;
}
protected T RefreshEntityFromDatabase(int id)
{
RefreshTransaction();
return(BasicRepository.Load(id));
}
// this injection is fine since the design hides this behind internal
internal QueryBuilder(BasicRepository repository)
{
this.repository = repository;
}
