public HttpResponseMessage GetUserTypes(UserTypeModel model)
{
IUnitOfWork uWork = new UnitOfWork();
IUserTypeRepository repo = new UserTypeRepository(uWork);
IUserTypeService userTypeService = new UserTypeService(repo);
try
{
if (this.ModelState.IsValid)
{
var userTypeList = userTypeService.GetAllUserTypeList(model);
if (userTypeList != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, userTypeList));
}
else
{
string message = "Error in getting Data";
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, message));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.InnerException.Message));
}
}
public New_Coach_Explenations()
{
this.InitializeComponent();
_signInFlow = ProgramContainer.container.GetInstance <ISignInFlow>();
_IPlayerRepository = ProgramContainer.container.GetInstance <IPlayerRepository>();
_userTypeRepository = ProgramContainer.container.GetInstance <UserTypeRepository>();
Coach coach = _signInFlow.NewCoachFlow();
if (Game_Hub.CoachAndPlayer)
{
_userTypeRepository.SaveUserType(coach.UserId, UserType.CoachAndPlayer);
((SignInFlow)_signInFlow).SaveUserToLocalStorage(UserType.Coach);
}
if (coach.FirstName == null)
{
this.Frame.Navigate(typeof(New_Coach));
return;
}
welcome.Text = "Hi " + coach.FirstName + ".\n" +
"\n" +
"You will soon add your first player, but before that you will need to enter your credit card number!\n" +
"\n" +
"As you recall in boost we use Crystals for games' cost.\n" +
"\n" +
"1 ILS is worth 100 Crystals so when you reward your player with crystals tha appropriate amount of money will be deducted from your bank account\n" +
"\n" +
"After that you will add your first player!\n";
}
public void Can_Perform_Delete_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
var id = user.Id;
using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
using (var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo))
{
repository2.Delete(user);
unitOfWork.Commit();
var resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
}
public UnitOfWork(EasyFindPropertiesEntities dbCtx)
{
_dbCtx = dbCtx;
PropertyType = new PropertyTypeRepository(_dbCtx);
AdPriority = new AdPriorityRepository(_dbCtx);
AdType = new AdTypeRepository(_dbCtx);
PropertyCategory = new PropertyCategoryRepository(_dbCtx);
PropertyCondition = new PropertyConditionRepository(_dbCtx);
PropertyImage = new PropertyImageRepository(_dbCtx);
PropertyPurpose = new PropertyPurposeRepository(_dbCtx);
PropertyRating = new PropertyRatingRepository(_dbCtx);
Property = new PropertyRepository(_dbCtx);
PropertyRequisition = new PropertyRequisitionRepository(_dbCtx);
SubscriptionType = new SubscriptionTypeRepository(_dbCtx);
Subscription = new SubscriptionRepository(_dbCtx);
TagType = new TagTypeRepository(_dbCtx);
Tennant = new TennantRepository(_dbCtx);
Owner = new OwnerRepository(_dbCtx);
Tags = new TagsRepository(_dbCtx);
Message = new MessageRepository(_dbCtx);
User = new UserRepository(_dbCtx);
UserType = new UserTypeRepository(_dbCtx);
UserTypeAssoc = new UserTypeAssocRepository(_dbCtx);
MessageTrash = new MessageTrashRepository(_dbCtx);
Meeting = new MeetingRepository(_dbCtx);
MeetingMembers = new MeetingMembersRepository(_dbCtx);
}
private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository)
{
userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, userTypeRepository);
return(repository);
}
public MapController(IConfiguration config, ShelterRepository shelterRepo, DogRepository dogRepo, UserTypeRepository userTypeRepo)
{
_config = config;
_shelterRepo = shelterRepo;
_dogRepo = dogRepo;
_userTypeRepo = userTypeRepo;
}
private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository)
{
userTypeRepository = new UserTypeRepository(unitOfWork, NullCacheProvider.Current);
var repository = new UserRepository(unitOfWork, NullCacheProvider.Current, userTypeRepository);
return(repository);
}
public AccountController(IConfiguration config, AccountUserRepository accountUserRepo, UserTypeRepository userTypeRepo, IMediator mediatr)
{
_config = config;
_mediatr = mediatr;
_accountUserRepo = accountUserRepo;
_userTypeRepo = userTypeRepo;
}
private void LoadUserTypeData()
{
TracktorDb context = new TracktorDb();
UserTypeRepository UserTypeRepo = new UserTypeRepository(context);
List <UserTypeEntity> UserTypes = UserTypeRepo.GetAll().ToList();
AllUserTypes = new BindingList <UserTypeEntity>(UserTypes);
}
private void LoadUserTypes()
{
var types = Utils.GetDefaultUserTypeList();
foreach (var type in types)
{
var x = UserTypeRepository.Add(type);
}
}
private async void LoadUserTypes()
{
var types = Utils.GetDefaultUserTypeList();
foreach (var type in types)
{
var x = await UserTypeRepository.AddAsync(type);
}
}
public static List <UserType> GetActiveUserTypes(int securityLevel)
{
List <UserType> ut;
using (CustomClearviewEntities ctx = new CustomClearviewEntities())
{
UserTypeRepository repo = new UserTypeRepository(ctx);
ut = repo.GetActiveItems().Where(x => x.SecurityLevel <= securityLevel).ToList();
}
return(ut);
}
public static UserType GetUserType(int id)
{
UserType ut;
using (CustomClearviewEntities ctx = new CustomClearviewEntities())
{
UserTypeRepository repo = new UserTypeRepository(ctx);
ut = repo.Find(id);
}
return(ut);
}
public static List <UserTypeData> GetUserTypes()
{
UserTypeRepository userTypeRep = new UserTypeRepository();
List <UserTypeData> userTypes = new List <UserTypeData>();
userTypeRep.GetAll().ToList().ForEach(x => userTypes.Add(new UserTypeData
{
Id = x.Id,
Name = x.Name
}));
return(userTypes);
}
public List <SelectListItem> GetAllUserTypes()
{
IUserTypeRepository userTypeRepo = new UserTypeRepository();
List <SelectListItem> userTypeList = new List <SelectListItem>();
userTypeList = userTypeRepo.GetAll().Select(x => new SelectListItem()
{
Text = x.UserType, Value = x.ID.ToString()
}
).ToList();
return(userTypeList);
}
public void GetAll_AllUserTypesReturned_CountEqualActual()
{
const int expectedCount = 2;
int actualCount;
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
actualCount = userTypeRepo.GetAll().Count();
}
Assert.AreEqual(expectedCount, actualCount);
}
private IUserType CreateAndCommitUserType()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
{
var userType = MockedUserType.CreateUserType();
repository.AddOrUpdate(userType);
unitOfWork.Commit();
return(userType);
}
}
public void DeleteById_WasDeleted_actualDataIsNull()
{
var typeIdToDelete = AddandGetTestUserType().ID;
UserType actualUserType;
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
userTypeRepo.Delete(typeIdToDelete);
userTypeRepo.SaveChanges();
actualUserType = userTypeRepo.GetById(typeIdToDelete);
}
Assert.IsNull(actualUserType);
}
private UserType AddandGetTestUserType()
{
var userTypeType = new UserType
{
Description = "TestUserType"
};
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
userTypeRepo.Add(userTypeType);
userTypeRepo.SaveChanges();
}
return(userTypeType);
}
public Game_Hub()
{
this.InitializeComponent();
_signInFlow = ProgramContainer.container.GetInstance <ISignInFlow>();
_IBalanceHandler = ProgramContainer.container.GetInstance <IBalanceHandler>();
_IUserTypeRepository = ProgramContainer.container.GetInstance <UserTypeRepository>();
player = _signInFlow.GetPlayer();
CoachAndPlayer = false;
if (_IUserTypeRepository.GetUserType(player.UserId).UserType == UserType.CoachAndPlayer)
{
ToBeACoach.Content = "Switch to Coach mode";
}
welcome.Text = "Hey " + player.FirstName + ", welcome to the game hub\n";
crystals.Text = "You have " + _IBalanceHandler.GetBalance() + " crystals!\n";
}
public UnitOfWork(ZeusDbContext context)
{
_context = context;
CourseRepository = new CourseRepository(_context);
GenderRepository = new GenderRepository(_context);
StatusRepository = new StatusRepository(_context);
UserTypeRepository = new UserTypeRepository(_context);
SubjectRepository = new SubjectRepository(_context);
UserRepository = new UserRepository(_context);
CareerRepository = new CareerRepository(_context);
CareerSubjectRepository = new CareerSubjectRepository(_context);
PeriodRepository = new PeriodRepository(_context);
SectionRepository = new SectionRepository(_context);
SubscriptionRepository = new SubscriptionRepository(_context);
}
public void GetById_CorrectDataGot_ActualEqualExpectedData()
{
var expectedUserType = new UserType
{
ID = 1,
Description = "User"
};
UserType actualUserType;
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
actualUserType = userTypeRepo.GetById(expectedUserType.ID);
}
AssertUserTypesEqual(expectedUserType, actualUserType);
}
private void InitializeRepositories()
{
ClientRepository = new ClientRepository(this.context);
ClientConditionRepository = new ClientConditionRepository(this.context);
ClientDrinkRepository = new ClientDrinkRepository(this.context);
ClientFoodRepository = new ClientFoodRepository(this.context);
ClientIncidentRepository = new ClientIncidentRepository(this.context);
ClientInformationRepository = new ClientInformationRepository(this.context);
DrinkRepository = new DrinkRepository(this.context);
FoodRepository = new FoodRepository(this.context);
IncidentRepository = new IncidentRepository(this.context);
IncidentPhotoRepository = new IncidentPhotoRepository(this.context);
UserRepository = new UserRepository(this.context);
UserIncidentRepository = new UserIncidentRepository(this.context);
UserTypeRepository = new UserTypeRepository(this.context);
MessageRepository = new MessageRepository(this.context);
}
public void Update_WasUserTypeUpdated_ActualEqualsExpectedData()
{
var expectedUserType = new UserType
{
ID = 1,
Description = "UpdatedUserType"
};
UserType actualUserType;
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
userTypeRepo.Update(expectedUserType);
actualUserType = userTypeRepo.GetById(expectedUserType.ID);
}
AssertUserTypesEqual(expectedUserType, actualUserType);
}
public void Add_WasUserTypeAdded_ActualEqualsExpectedData()
{
var expectedUserType = new UserType
{
Description = "NewTestType"
};
UserType actualUserType;
using (var userTypeRepo = new UserTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
userTypeRepo.Add(expectedUserType);
userTypeRepo.SaveChanges();
actualUserType = userTypeRepo.GetById(expectedUserType.ID);
}
AssertUserTypesEqual(expectedUserType, actualUserType);
}
/// <summary>
/// Runs prior to the work being done.
/// </summary>
protected override void PreExecute()
{
WellKnownError = new WellKnownErrors();
TranscriptionRepository = new TranscriptionRepository();
RepositoryRepository = new RepositoryRepository();
CollectionRepository = new CollectionRepository();
SubseryRepository = new SubseryRepository();
SubjectRepository = new SubjectRepository();
KeywordRepository = new KeywordRepository();
PredefineUserRepository = new PredefineUserRepository();
AudioEquipmentUsedRepository = new AudioEquipmentUsedRepository();
VideoEquipmentUsedRepository = new VideoEquipmentUsedRepository();
UserTypeRepository = new UserTypeRepository();
WellKnownError.Value = WellKnownError.NoError;
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Branches = new BranchRepository(_context);
BankBalance = new BankBalanceRepository(_context);
CusAccountType = new CusAccountTypeRepository(_context);
Customer = new CustomerRepository(_context);
CusTransection = new CusTransectionRepository(_context);
Employee = new EmployeeRepository(_context);
EmpSalary = new EmpSalaryRepository(_context);
Login = new LoginRepository(_context);
Manager = new ManagerRepository(_context);
MangrTransection = new MangrTransectionRepository(_context);
ManNoticeBoard = new ManNoticeBoardRepository(_context);
ManSalary = new ManSalaryRepository(_context);
Md = new MdRepository(_context);
UserInfo = new UserInfoRepository(_context);
UserType = new UserTypeRepository(_context);
}
public NewUnassignedPlayerExplenations()
{
_signInFlow = ProgramContainer.container.GetInstance <ISignInFlow>();
this.InitializeComponent();
_userTypeRepository = ProgramContainer.container.GetInstance <UserTypeRepository>();
player = _signInFlow.GetPlayer();
if (Coach_Lobby.CoachAndPlayer)
{
_userTypeRepository.SaveUserType(player.UserId, UserType.CoachAndPlayer);
((SignInFlow)_signInFlow).SaveUserToLocalStorage(UserType.Player);
}
welcome.Text = "Hi " + player.FirstName + ".\n" +
"You will soon see the goals your coach assigned you, but first... some explanations about boost\n" +
"\n" +
"Your coach assigned you daily (and possibly) weekly goals, once you complete a goal you will recive a certian amount of crystals (chosen by your coach). But you can also get crystals if your coach is impressed by a certian activity you had.\n" +
"\n" +
"You can spend Your crystals in the Game Hub. There you will be able to play cool and exciting games such as Tic Tac Toe !\n" +
"\n" +
"Are you ready?\n";
}
public void Default_User_Permissions_Based_On_User_Type()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
using (var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo))
{
// Act
var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1", "test", "media");
repository.AddOrUpdate(user1);
unitOfWork.Commit();
// Assert
Assert.AreEqual(3, user1.DefaultPermissions.Count());
Assert.AreEqual("A", user1.DefaultPermissions.ElementAt(0));
Assert.AreEqual("B", user1.DefaultPermissions.ElementAt(1));
Assert.AreEqual("C", user1.DefaultPermissions.ElementAt(2));
}
}
public static UserData GetUser(int id)
{
UserRepository userRep = new UserRepository();
UserTypeRepository userTypeRep = new UserTypeRepository();
User userDao = userRep.Get(id);
UserData user = new UserData
{
Id = userDao.Id,
Username = userDao.Username,
Password = userDao.Password,
UserType = new UserTypeData
{
Id = userTypeRep.Get(userDao.UserTypeId).Id,
Name = userTypeRep.Get(userDao.UserTypeId).Name
},
UserTypeId = userDao.UserTypeId,
FullName = userDao.FullName,
Address = userDao.Address,
PhoneNumber = userDao.PhoneNumber
};
return(user);
}
public IList<tb_UserType> GetAllUserType()
{
_repository = new UserTypeRepository();
return _repository.GetAllUserType();
}
private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository)
{
userTypeRepository = new UserTypeRepository(unitOfWork, NullCacheProvider.Current);
var repository = new UserRepository(unitOfWork, NullCacheProvider.Current, userTypeRepository);
return repository;
}
