public void GetByKey_ReturnsIncomeAndExpense()
{
string expectedTransactionTypesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"TransactionTypes.json");
var expectedTransactionTypes = JsonConvert.DeserializeObject <List <TransactionType> >(expectedTransactionTypesJson);
var expectedIncome = expectedTransactionTypes
.First(t => t.Name == TransactionType.Options.Income.ToString());
var expectedExpense = expectedTransactionTypes
.First(t => t.Name == TransactionType.Options.Expense.ToString());
TransactionTypeRepository
.Setup(r => r.GetByKey(TransactionType.Options.Income.ToString())).Returns(expectedIncome);
TransactionTypeRepository
.Setup(r => r.GetByKey(TransactionType.Options.Expense.ToString())).Returns(expectedExpense);
var actualIncome = TransactionTypeService.GetByKey(TransactionType.Options.Income.ToString());
var actualExpense = TransactionTypeService.GetByKey(TransactionType.Options.Expense.ToString());
Assert.NotNull(actualIncome);
Assert.NotNull(actualExpense);
Assert.Equal(actualIncome.Name, expectedIncome.Name);
Assert.Equal(actualIncome.IconUrl, expectedIncome.IconUrl);
Assert.Equal(actualExpense.Name, expectedExpense.Name);
Assert.Equal(actualExpense.IconUrl, expectedExpense.IconUrl);
}
public async Task <ISingleResponse <vmTransactionPrepareRequest> > PrepareTransactionRelatedRequestAsync(int currentUid)
{
var response = new SingleResponse <vmTransactionPrepareRequest>();
try
{
// Retrieve PaymentMethods list
response.Model.PaymentMethods = await PaymentMethodRepository.GetListPaymentMethodAsync();
// Retrieve PaymentPayors list
response.Model.PaymentPayors = await PaymentPayorRepository.GetListPaymentPayorAsync(currentUid);
// Retrieve TransactionCategorys list
response.Model.TransactionCategorys = await TransactionCategoryRepository.GetListTransactionCategoryAsync();
// Retrieve TransactionTypes list
response.Model.TransactionTypes = await TransactionTypeRepository.GetListTransactionTypeAsync();
}
catch (Exception ex)
{
response.SetError(ex);
}
return(response);
}
private void Setup_Repository_FakeDbContext(List <TransactionType> fakeTransactionTypes)
{
// setup dbContext
Setup_FakeDbContext(fakeTransactionTypes);
// set up repository
_repository = new TransactionTypeRepository(_fakeDbContext);
}
// GET: Create A Single ClientFee
public ActionResult Create()
{
int productId = 1;
//Check Access Rights to Domain
if (!hierarchyRepository.AdminHasDomainWriteAccess(groupName))
{
ViewData["Message"] = "You do not have access to this item";
return View("Error");
}
ProductRepository productRepository = new ProductRepository();
Product product = new Product();
product = productRepository.GetProduct(productId);
TransactionFeeAirVM transactionFeeVM = new TransactionFeeAirVM();
TransactionFeeAir transactionFee = new TransactionFeeAir();
transactionFee.ProductName = product.ProductName;
transactionFee.ProductId = product.ProductId;
transactionFee.IncursGSTFlagNonNullable = false;
transactionFeeVM.TransactionFee = transactionFee;
TravelIndicatorRepository travelIndicatorRepository = new TravelIndicatorRepository();
transactionFeeVM.TravelIndicators = new SelectList(travelIndicatorRepository.GetAllTravelIndicators().ToList(), "TravelIndicator1", "TravelIndicatorDescription");
BookingSourceRepository bookingSourceRepository = new BookingSourceRepository();
transactionFeeVM.BookingSources = new SelectList(bookingSourceRepository.GetAllBookingSources().ToList(), "BookingSourceCode", "BookingSourceCode");
BookingOriginationRepository bookingOriginationRepository = new BookingOriginationRepository();
transactionFeeVM.BookingOriginations = new SelectList(bookingOriginationRepository.GetAllBookingOriginations().ToList(), "BookingOriginationCode", "BookingOriginationCode");
ChargeTypeRepository chargeTypeRepository = new ChargeTypeRepository();
transactionFeeVM.ChargeTypes = new SelectList(chargeTypeRepository.GetAllChargeTypes().ToList(), "ChargeTypeCode", "ChargeTypeDescription");
TransactionTypeRepository transactionTypeRepository = new TransactionTypeRepository();
transactionFeeVM.TransactionTypes = new SelectList(transactionTypeRepository.GetAllTransactionTypes().ToList(), "TransactionTypeCode", "TransactionTypeCode");
FeeCategoryRepository feeCategoryRepository = new FeeCategoryRepository();
transactionFeeVM.FeeCategories = new SelectList(feeCategoryRepository.GetAllFeeCategories().ToList(), "FeeCategory1", "FeeCategory1");
TravelerBackOfficeTypeRepository travelerBackOfficeTypeRepository = new TravelerBackOfficeTypeRepository();
transactionFeeVM.TravelerBackOfficeTypes = new SelectList(travelerBackOfficeTypeRepository.GetAllTravelerBackOfficeTypes().ToList(), "TravelerBackOfficeTypeCode", "TravelerBackOfficeTypeDescription");
TripTypeClassificationRepository tripTypeClassificationRepository = new TripTypeClassificationRepository();
transactionFeeVM.TripTypeClassifications = new SelectList(tripTypeClassificationRepository.GetAllTripTypeClassifications().ToList(), "TripTypeClassificationId", "TripTypeClassificationDescription");
CurrencyRepository currencyRepository = new CurrencyRepository();
transactionFeeVM.TicketPriceCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
transactionFeeVM.FeeCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
PolicyRouting policyRouting = new PolicyRouting();
policyRouting.FromGlobalFlag = false;
policyRouting.ToGlobalFlag = false;
transactionFeeVM.PolicyRouting = policyRouting;
return View(transactionFeeVM);
}
public void BasicUsage()
{
var context = this.context;
var repository = new TransactionTypeRepository(context);
var allTypes = repository.GetAll();
Assert.Equal(1, allTypes.Count());
}
public void WhenIncludingBackouts_AllActiveRecordsInResults()
{
var context = this.context;
var repository = new TransactionTypeRepository(context);
var allTypes = repository.GetAll(excludeBackouts: false);
Assert.Equal(2, allTypes.Count());
}
public UnitOfWork(LascarizadorDbContext context)
{
_context = context;
Clients = new ClientRepository(_context);
CardBrands = new CardBrandRepository(_context);
CardTypes = new CardTypeRepository(_context);
Cards = new CardRepository(_context);
Transactions = new TransactionRepository(_context);
TransactionTypes = new TransactionTypeRepository(_context);
TransactionLogs = new TransactionLogRepository(_context);
ErrorLogs = new ErrorLogRepository(_context);
}
public StudentController()
{
_repository = new PeriodGradeStudentRepository();
_periodRepository = new PeriodRepository();
_gradeRepository = new GradeRepository();
_genderRepository = new GenderRepository();
_studentRepository = new StudentRepository();
_transactionTypeRepository = new TransactionTypeRepository();
_periodGradeStudentRepository = new PeriodGradeStudentRepository();
_studentPayConfigurationRepository = new StudentPayConfigurationRepository();
_cityRepository = new CityRepository();
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Individuals = new IndividualRepository(context);
BankAccounts = new BankAccountRepository(context);
Requests = new RequestRepository(context);
Users = new ApplicationUserRepository(context);
BankAccountTypes = new BankAccountTypeRepository(context);
BankAccountRequests = new BankAccountRequestRepository(context);
Transactions = new TransactionsRepository(context);
TransactionTypes = new TransactionTypeRepository(context);
}
public void SetUp()
{
// setup fake model
_dbTransactionType = new TransactionType {
Id = 1, Name = "a", IsActive = true
};
// setup DbContext
Setup_FakeDbContext();
// set up repository
_repository = new TransactionTypeRepository(_fakeDbContext);
}
public void GetAll_ReturnsAll()
{
string expectedTransactionTypesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"TransactionTypes.json");
var expectedTransactionTypes = JsonConvert.DeserializeObject <List <TransactionType> >(expectedTransactionTypesJson);
TransactionTypeRepository.Setup(r => r.GetAll()).Returns(expectedTransactionTypes);
var actualTransactionTypes = TransactionTypeService.GetAll();
Assert.NotNull(actualTransactionTypes);
Assert.Equal(expectedTransactionTypes.Count, actualTransactionTypes.Count());
}
public void BasicUsage()
{
var context = this.factory.Create();
context.Database.Log = this.output.WriteLine;
var repository = new TransactionTypeRepository(context);
var allTypes = repository.GetAll();
context.Dispose();
Assert.Equal(2, allTypes.Count());
}
public void WhenIncludingBackouts_AllActiveRecordsInResults()
{
var context = this.factory.Create();
context.Database.Log = this.output.WriteLine;
var repository = new TransactionTypeRepository(context);
var allTypes = repository.GetAll(excludeBackouts: false);
context.Dispose();
Assert.Equal(4, allTypes.Count());
}
public DonationInformation()
{
//dtpDate.MinDate = DateTime.Now;
this.MaximizeBox = false;
InitializeComponent();
dtpEnglishDateType.Format = DateTimePickerFormat.Custom;
dtpEnglishDateType.CustomFormat = "dd/MM";
donorRepo = new DonorRepository();
datetypeRepo = new DateTypeRepository();
desigRepo = new DesignationRepository();
employeeRepo = new EmployeeRepository();
prefixRepo = new PrefixesRepository();
roleRepo = new RoleRepository();
serviceNameRepo = new ServiceNameRepository();
serviceTypeRepo = new ServiceTypeRepository();
specialDayRepo = new SpecialDayRepository();
starRepo = new StarsRepository();
monthsRepo = new MonthsRepository();
pakshaRepo = new PakshaRepository();
thithiRepo = new ThidhiRepository();
monthlyAnnaRepo = new MonthlyAnnaRepository();
gothramRepo = new GothramsRepository();
transTypeRepo = new TransactionTypeRepository();
lstTokenPrint = new List<TokenPrint>();
stateRepo = new StateRepository();
lstStates = new List<State>();
prefixesRepo = new PrefixesRepository();
bindData();
btnUpdate.Visible = false;
btnCancel.Visible = false;
lblSpecialDay.Visible = false;
cmbSpecialDay.Visible = false;
lblMonth.Visible = false;
cmbMonth.Visible = false;
lblThithi.Visible = false;
cmbThithi.Visible = false;
lblMonthlyAnna.Visible = false;
cmbMonthlyAnna.Visible = false;
lblEnglishDatetype.Visible = false;
dtpEnglishDateType.Visible = false;
rbdEnglish.Checked = false;
rbdTelugu.Checked = false;
lblMonthyAnnaThithi.Visible = false;
cmbMonthyAnnaThithi.Visible = false;
}
public async Task Create_ReturnsNewCategory()
{
const int testingUserId = 1;
string transactionTypesJson =
File.ReadAllText(TestConfiguration.MockDataFolderPath + @"TransactionTypes.json");
var transactionTypes = JsonConvert.DeserializeObject <List <TransactionType> >(transactionTypesJson);
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == testingUserId);
var category = new Category
{
Name = "Test category",
TypeName = TransactionType.Options.Income.ToString(),
IsCustom = true
};
UserContext.Setup(c => c.GetUserId()).Returns(testingUserId);
UserRepository.Setup(u => u.GetByKey(testingUserId)).Returns(user);
TransactionTypeRepository
.Setup(t => t.GetByKey(TransactionType.Options.Income.ToString()))
.Returns(transactionTypes.First(t => t.Name == TransactionType.Options.Income.ToString()));
TransactionTypeRepository
.Setup(t => t.GetByKey(TransactionType.Options.Expense.ToString()))
.Returns(transactionTypes.First(t => t.Name == TransactionType.Options.Expense.ToString()));
CategoryRepository
.Setup(c => c.Create(category))
.ReturnsAsync(category);
var categoryService = new CategoryService(ContextProvider.Object, UserContext.Object, EventManager.Object);
var resultCategory = await categoryService.Create(category);
Assert.NotNull(resultCategory);
Assert.NotNull(resultCategory.Type);
Assert.NotNull(resultCategory.User);
Assert.Equal(category.Name, resultCategory.Name);
Assert.Equal(category.IsCustom, resultCategory.IsCustom);
Assert.Equal(category.Type.Name, resultCategory.Type.Name);
Assert.Equal(category.User.Id, resultCategory.User.Id);
Assert.Equal("/static/icons/categories/unknown.png", resultCategory.IconUrl);
}
private void SetRepositories()
{
AssetSettings = new AssetSettingRepository(_context);
AssetRelationships = new AssetRelationshipRepository(_context);
Assets = new AssetRepository(_context);
AssetTransactions = new AssetTransactionRepository(_context);
AssetTypeSettingTypes = new AssetTypeSettingTypeRepository(_context);
AssetTypeRelationshipTypes = new AssetTypeRelationshipTypeRepository(_context);
AssetTypes = new AssetTypeRepository(_context);
ParentChildRelationshipTypes = new ParentChildRelationshipTypeRepository(_context);
RelationshipTypes = new RelationshipTypeRepository(_context);
SettingTypes = new SettingTypeRepository(_context);
TransactionCategories = new TransactionCategoryRepository(_context);
TransactionDescriptions = new TransactionDescriptionRepository(_context);
TransactionTypes = new TransactionTypeRepository(_context);
}
public UnitOfWork(DataContext context)
{
_context = context;
Account = new AccountRepository(_context);
AccountHistory = new AccountHistoryRepository(_context);
AccountType = new AccountTypeRepository(_context);
Business = new BusinessRepository(_context);
Client = new ClientRepository(_context);
Group = new GroupRepository(_context);
Relationship = new RelationshipRepository(_context);
Role = new RoleRepository(_context);
Transaction = new TransactionRepository(_context);
TransactionType = new TransactionTypeRepository(_context);
User = new UserRepository(_context);
UserHistory = new UserHistoryRepository(_context);
}
public async Task CreateTransactionTypeAsync_Returns_New_GetTransactionTypeDto()
{
//Arrange
_fixture.MockTransactionTypeService.Setup(x => x.AddTransactionTypeAsync(It.IsAny <TransactionType>()))
.ReturnsAsync(_fixture.CreatedNewTransactionType);
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
var result = await repository.CreateTransactionTypeAsync(_fixture.CreateTransactionTypeDto);
//Assert
result.Should().BeOfType(typeof(GetTransactionTypeDto));
result.Id.Should().Be(6);
result.Type.Should().Be(_fixture.CreateTransactionTypeDto.Type);
}
public void WhenAdding_NewIdIsGenerated()
{
var context = this.context;
var repository = new TransactionTypeRepository(context);
var item = new TransactionType {
Abbreviation = "X", Active = true, BackOutType = false, Name = "Extension"
};
repository.Insert(item);
this.output.WriteLine("{0}", item.Id);
Assert.True(item.Id > 0);
}
public async Task GetTransactionTypesAsync_Returns_GetTransactionTypeDtos()
{
//Arrange
_fixture.MockTransactionTypeService.Setup(x => x.GetTransactionTypesAsync())
.ReturnsAsync(_fixture.TransactionTypes);
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
var result = await repository.GetTransactionTypesAsync();
//Assert
var transactionTypes = result.Should().BeAssignableTo <IEnumerable <GetTransactionTypeDto> >().Subject;
transactionTypes.Should().HaveCount(5);
}
public async Task GetTransactionTypeAsync_Returns_GetTransactionTypeDto()
{
//Arrange
var id = 1;
_fixture.MockTransactionTypeService.Setup(x => x.GetTransactionTypeAsync(It.IsAny <Expression <Func <TransactionType, bool> > >()))
.Returns <Expression <Func <TransactionType, bool> > >(expression => Task.FromResult(_fixture.TransactionTypes.AsQueryable().FirstOrDefault(expression)));
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
var result = await repository.GetTransactionTypeAsync(id);
//Assert
result.Should().BeOfType(typeof(GetTransactionTypeDto));
result.Id.Should().Be(id);
result.Type.Should().Be("Food");
}
public async Task GetTransactionTypeAsync_Throws_NotFoundException()
{
//Arrange
var id = 201;
_fixture.MockTransactionTypeService.Setup(x => x.GetTransactionTypeAsync(It.IsAny <Expression <Func <TransactionType, bool> > >()))
.Returns <Expression <Func <TransactionType, bool> > >(expression => Task.FromResult(_fixture.TransactionTypes.AsQueryable().FirstOrDefault(expression)));
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
var exception = await Assert.ThrowsAsync <RestException>(() => repository.GetTransactionTypeAsync(id));
//Assert
exception.ErrorCode.Should().Be(HttpStatusCode.NotFound);
exception.ErrorMessage.Should().Be("Transaction type not found.");
exception.ErrorType.Should().Be(HttpStatusCode.NotFound.ToString());
}
public async Task CreateTransactionTypeAsync_Throws_ConflictException()
{
//Arrange
_fixture.MockTransactionTypeService.Setup(x => x.GetTransactionTypeAsync(It.IsAny <Expression <Func <TransactionType, bool> > >()))
.Returns <Expression <Func <TransactionType, bool> > >(expression => Task.FromResult(_fixture.TransactionTypes.AsQueryable().FirstOrDefault(expression)));
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
var exception = await Assert.ThrowsAsync <RestException>(() => repository.CreateTransactionTypeAsync(new CreateTransactionTypeDto {
Type = "Food"
}));
//Assert
exception.ErrorCode.Should().Be(HttpStatusCode.Conflict);
exception.ErrorMessage.Should().Be("Transaction type \"Food\" is already available.");
exception.ErrorType.Should().Be(HttpStatusCode.Conflict.ToString());
}
public async Task DeleteTransactionTypeAsync_Returns_NoResult()
{
//Arrange
var id = 2;
_fixture.MockTransactionTypeService.Setup(x => x.GetTransactionTypeAsync(It.IsAny <Expression <Func <TransactionType, bool> > >()))
.Returns <Expression <Func <TransactionType, bool> > >(expression => Task.FromResult(_fixture.TransactionTypes.AsQueryable().FirstOrDefault(expression)));
_fixture.MockTransactionTypeService.Setup(x => x.DeleteTransactionTypeAsync(It.IsAny <TransactionType>()));
var repository = new TransactionTypeRepository(AutoMapperSingleton.Mapper, _fixture.MockTransactionTypeService.Object);
//Act
await repository.DeleteTransactionTypeAsync(id);
// Assert
_fixture.MockTransactionTypeService.Verify(x => x.DeleteTransactionTypeAsync(It.IsAny <TransactionType>()), Times.Once);
}
public UnitOfWork(DataContext context)
{
_context = context;
Account = new AccountRepository(_context);
AccountHistory = new AccountHistoryRepository(_context);
AccountType = new AccountTypeRepository(_context);
Business = new BusinessRepository(_context);
Client = new ClientRepository(_context);
Group = new GroupRepository(_context);
Relationship = new RelationshipRepository(_context);
Role = new RoleRepository(_context);
Transaction = new TransactionRepository(_context);
TransactionCode = new TransactionCodeRepository(_context);
TransactionType = new TransactionTypeRepository(_context);
TransactionTypeDetail = new TransactionTypeDetailRepository(_context);
User = new UserRepository(_context);
UserHistory = new UserHistoryRepository(_context);
UserActivity = new UserActivityRepository(_context);
Menu = new MenuRepository(_context);
Control = new ControlRepository(_context);
Image = new ImageRepository(_context);
}
public SchemaRepositoryContainer()
{
#region Entity Repositories
City = new CityRepository();
Cities_Archive = new Cities_ArchiveRepository();
Country = new CountryRepository();
Countries_Archive = new Countries_ArchiveRepository();
DeliveryMethod = new DeliveryMethodRepository();
DeliveryMethods_Archive = new DeliveryMethods_ArchiveRepository();
PaymentMethod = new PaymentMethodRepository();
PaymentMethods_Archive = new PaymentMethods_ArchiveRepository();
Person = new PersonRepository();
People_Archive = new People_ArchiveRepository();
StateProvince = new StateProvinceRepository();
StateProvinces_Archive = new StateProvinces_ArchiveRepository();
SystemParameter = new SystemParameterRepository();
TransactionType = new TransactionTypeRepository();
TransactionTypes_Archive = new TransactionTypes_ArchiveRepository();
#endregion
// If not implemented this method is removed during compilation
LoadCustomRepositories();
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_appDbConnectionFactory);
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {new BasicAuthProvider(), new CredentialsAuthProvider(),}) {HtmlRedirect = null});
//No use a custom one
//Plugins.Add(new RegistrationFeature());
var userRepo = new OrmLiteAuthRepository(_authDbConnectionFactory);
container.Register<IUserAuthRepository>(userRepo);
//wire-up a validator for the UserRegistrationService
var userRegistrationValidator = new UserRegistrationRequestValidator {UserAuthRepo = userRepo};
container.Register<IValidator<UserRegistrationRequest>>(userRegistrationValidator);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _appDbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
}
public void WhenAdding_NewIdIsGenerated()
{
using (var ts = new TransactionScope())
{
var context = this.factory.Create();
context.Database.Log = this.output.WriteLine;
var repository = new TransactionTypeRepository(context);
var item = new TransactionType {
Abbreviation = "X", Active = true, BackOutType = false, Name = "Extension"
};
repository.Insert(item);
context.Dispose();
this.output.WriteLine("{0}", item.Id);
Assert.True(item.Id > 0);
}
}
public TransactionTypeService()
{
_repository = new TransactionTypeRepository();
}
// GET: Create TransactionFeeAir
public ActionResult Edit(int id)
{
//Check Access Rights to Domain
if (!hierarchyRepository.AdminHasDomainWriteAccess(groupName))
{
ViewData["Message"] = "You do not have access to this item";
return View("Error");
}
TransactionFeeAir transactionFeeAir = new TransactionFeeAir();
transactionFeeAir = transactionFeeAirRepository.GetItem(id);
if (transactionFeeAir == null || transactionFeeAir.ProductId != 1)
{
ViewData["ActionMethod"] = "EditAirGet";
return View("RecordDoesNotExistError");
}
transactionFeeAir.IncursGSTFlagNonNullable = ((bool)transactionFeeAir.IncursGSTFlag == true) ? true : false;
TransactionFeeAirVM transactionFeeVM = new TransactionFeeAirVM();
transactionFeeVM.TransactionFee = transactionFeeAir;
TravelIndicatorRepository travelIndicatorRepository = new TravelIndicatorRepository();
transactionFeeVM.TravelIndicators = new SelectList(travelIndicatorRepository.GetAllTravelIndicators().ToList(), "TravelIndicator1", "TravelIndicatorDescription");
BookingSourceRepository bookingSourceRepository = new BookingSourceRepository();
transactionFeeVM.BookingSources = new SelectList(bookingSourceRepository.GetAllBookingSources().ToList(), "BookingSourceCode", "BookingSourceCode");
BookingOriginationRepository bookingOriginationRepository = new BookingOriginationRepository();
transactionFeeVM.BookingOriginations = new SelectList(bookingOriginationRepository.GetAllBookingOriginations().ToList(), "BookingOriginationCode", "BookingOriginationCode");
ChargeTypeRepository chargeTypeRepository = new ChargeTypeRepository();
transactionFeeVM.ChargeTypes = new SelectList(chargeTypeRepository.GetAllChargeTypes().ToList(), "ChargeTypeCode", "ChargeTypeDescription");
TransactionTypeRepository transactionTypeRepository = new TransactionTypeRepository();
transactionFeeVM.TransactionTypes = new SelectList(transactionTypeRepository.GetAllTransactionTypes().ToList(), "TransactionTypeCode", "TransactionTypeCode");
FeeCategoryRepository feeCategoryRepository = new FeeCategoryRepository();
transactionFeeVM.FeeCategories = new SelectList(feeCategoryRepository.GetAllFeeCategories().ToList(), "FeeCategory1", "FeeCategory1");
TravelerBackOfficeTypeRepository travelerBackOfficeTypeRepository = new TravelerBackOfficeTypeRepository();
transactionFeeVM.TravelerBackOfficeTypes = new SelectList(travelerBackOfficeTypeRepository.GetAllTravelerBackOfficeTypes().ToList(), "TravelerBackOfficeTypeCode", "TravelerBackOfficeTypeDescription");
TripTypeClassificationRepository tripTypeClassificationRepository = new TripTypeClassificationRepository();
transactionFeeVM.TripTypeClassifications = new SelectList(tripTypeClassificationRepository.GetAllTripTypeClassifications().ToList(), "TripTypeClassificationId", "TripTypeClassificationDescription");
CurrencyRepository currencyRepository = new CurrencyRepository();
transactionFeeVM.TicketPriceCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
transactionFeeVM.FeeCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
PolicyRouting policyRouting = new PolicyRouting();
if (transactionFeeAir.PolicyRoutingId != null)
{
policyRouting = policyRoutingRepository.GetPolicyRouting((int)transactionFeeAir.PolicyRoutingId);
policyRoutingRepository.EditPolicyRouting(policyRouting);
}
//
transactionFeeVM.PolicyRouting = policyRouting;
return View(transactionFeeVM);
}
public void CreateTransactionType(TransactionType transactionType)
{
var repository = new TransactionTypeRepository(_db);
repository.Add(transactionType);
repository.Save();
}
public void UpdateTransactionType(TransactionType transactionType)
{
var repository = new TransactionTypeRepository(_db);
repository.Edit(transactionType);
repository.Save();
}
public ICollection<TransactionType> GetTransactionTypes()
{
var repository = new TransactionTypeRepository(_db);
return repository.GetAll().ToList();
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_appDbConnectionFactory);
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider(), new CredentialsAuthProvider(), })
{
HtmlRedirect = null
});
//No use a custom one
//Plugins.Add(new RegistrationFeature());
var userRepo = new OrmLiteAuthRepository(_authDbConnectionFactory);
container.Register <IUserAuthRepository>(userRepo);
//wire-up a validator for the UserRegistrationService
var userRegistrationValidator = new UserRegistrationRequestValidator {
UserAuthRepo = userRepo
};
container.Register <IValidator <UserRegistrationRequest> >(userRegistrationValidator);
var currencyTypeRepository = new CurrencyTypeRepository {
DbConnectionFactory = _appDbConnectionFactory
};
var transactionTypeRepository = new TransactionTypeRepository {
DbConnectionFactory = _appDbConnectionFactory
};
var transactionStatusTypeRepository = new TransactionStatusTypeRepository {
DbConnectionFactory = _appDbConnectionFactory
};
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository {
DbConnectionFactory = _appDbConnectionFactory
};
var transactionRepository = new TransactionRepository {
DbConnectionFactory = _appDbConnectionFactory
};
var currencyTypeLogic = new CurrencyTypeLogic {
Repository = currencyTypeRepository
};
var transactionTypeLogic = new TransactionTypeLogic {
Repository = transactionTypeRepository
};
var transactionStatusTypeLogic = new TransactionStatusTypeLogic {
Repository = transactionStatusTypeRepository
};
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic {
Repository = transactionNotificationStatusTypeRepository
};
var transactionLogic = new TransactionLogic {
Repository = transactionRepository
};
container.Register <IRest <CurrencyType, GetCurrencyTypes> >(currencyTypeLogic);
container.Register <IRest <TransactionType, GetTransactionTypes> >(transactionTypeLogic);
container.Register <IRest <TransactionStatusType, GetTransactionStatusTypes> >(transactionStatusTypeLogic);
container.Register <IRest <TransactionNotificationStatusType, GetTransactionNotificationStatusTypes> >(transactionNotificationStatusTypeLogic);
container.Register <IRest <Transaction, GetTransactions> >(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
}
public void DeleteTransactionType(int Id)
{
var repository = new TransactionTypeRepository(_db);
repository.Delete(Id);
repository.Save();
}
public TransactionType GetTransactionType(int Id)
{
var repository = new TransactionTypeRepository(_db);
return repository.FindBy(c => c.Id == Id).SingleOrDefault();
}
// GET: Create A Single Transaction Fee
public ActionResult Create(int productId)
{
//Check Access Rights to Domain
if (!hierarchyRepository.AdminHasDomainWriteAccess(groupName))
{
ViewData["Message"] = "You do not have access to this item";
return(View("Error"));
}
ProductRepository productRepository = new ProductRepository();
Product product = new Product();
product = productRepository.GetProduct(productId);
if (product == null || productId < 2 || productId > 3)
{
ViewData["ActionMethod"] = "CreateGet";
return(View("RecordDoesNotExistError"));
}
TransactionFeeCarHotelVM transactionFeeVM = new TransactionFeeCarHotelVM();
TransactionFeeCarHotel transactionFeeCarHotel = new TransactionFeeCarHotel();
transactionFeeCarHotel.ProductName = product.ProductName;
transactionFeeCarHotel.ProductId = product.ProductId;
transactionFeeCarHotel.IncursGSTFlagNonNullable = false;
transactionFeeVM.TransactionFee = transactionFeeCarHotel;
TravelIndicatorRepository travelIndicatorRepository = new TravelIndicatorRepository();
transactionFeeVM.TravelIndicators = new SelectList(travelIndicatorRepository.GetAllTravelIndicators().ToList(), "TravelIndicator1", "TravelIndicatorDescription");
BookingSourceRepository bookingSourceRepository = new BookingSourceRepository();
transactionFeeVM.BookingSources = new SelectList(bookingSourceRepository.GetAllBookingSources().ToList(), "BookingSourceCode", "BookingSourceCode");
BookingOriginationRepository bookingOriginationRepository = new BookingOriginationRepository();
transactionFeeVM.BookingOriginations = new SelectList(bookingOriginationRepository.GetAllBookingOriginations().ToList(), "BookingOriginationCode", "BookingOriginationCode");
ChargeTypeRepository chargeTypeRepository = new ChargeTypeRepository();
transactionFeeVM.ChargeTypes = new SelectList(chargeTypeRepository.GetAllChargeTypes().ToList(), "ChargeTypeCode", "ChargeTypeDescription");
TransactionTypeRepository transactionTypeRepository = new TransactionTypeRepository();
transactionFeeVM.TransactionTypes = new SelectList(transactionTypeRepository.GetAllTransactionTypes().ToList(), "TransactionTypeCode", "TransactionTypeCode");
FeeCategoryRepository feeCategoryRepository = new FeeCategoryRepository();
transactionFeeVM.FeeCategories = new SelectList(feeCategoryRepository.GetAllFeeCategories().ToList(), "FeeCategory1", "FeeCategory1");
TravelerBackOfficeTypeRepository travelerBackOfficeTypeRepository = new TravelerBackOfficeTypeRepository();
transactionFeeVM.TravelerBackOfficeTypes = new SelectList(travelerBackOfficeTypeRepository.GetAllTravelerBackOfficeTypes().ToList(), "TravelerBackOfficeTypeCode", "TravelerBackOfficeTypeDescription");
TripTypeClassificationRepository tripTypeClassificationRepository = new TripTypeClassificationRepository();
transactionFeeVM.TripTypeClassifications = new SelectList(tripTypeClassificationRepository.GetAllTripTypeClassifications().ToList(), "TripTypeClassificationId", "TripTypeClassificationDescription");
CurrencyRepository currencyRepository = new CurrencyRepository();
transactionFeeVM.TicketPriceCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
transactionFeeVM.FeeCurrencies = new SelectList(currencyRepository.GetAllCurrencies().ToList(), "CurrencyCode", "Name");
//Location is used in CarHotel only
PolicyLocationRepository policyLocationRepository = new PolicyLocationRepository();
transactionFeeVM.PolicyLocations = new SelectList(policyLocationRepository.GetAllPolicyLocations().ToList(), "PolicyLocationId", "PolicyLocationName");
return(View(transactionFeeVM));
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_dbConnectionFactory);
var basicAuthProvider = new BasicAuthProvider();
container.Register(basicAuthProvider);
Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl ));
var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory);
container.Register<IAuthRepository>(userRepo);
var cacheClient = new MemoryCacheClient();
container.Register(cacheClient);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
var redisLocation = ConfigurationManager.AppSettings["ReddisService"];
Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation));
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) };
Func<IMessage, IMessage> filterSecureRequests = (message) =>
{
/*
var tag = message.Tag;
if (string.IsNullOrWhiteSpace(tag))
return message;
if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase))
{
var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5)));
var i = creds.IndexOf(':');
var userName = creds.Substring(0, i);
var userPass = creds.Substring(i + 1);
if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass)
{
message.Tag = null;
return message;
}
_currentSessionGuid = Guid.NewGuid();
var sessionKey = userName + "/" + _currentSessionGuid.ToString("N");
SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName };
container.Register(SessionContext);
message.Tag = sessionKey;
return message;
}
message.Tag = null;*/
return message;
};
mqService.RequestFilter = filterSecureRequests;
Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) =>
{
var service = new TransactionWebService { Logic = transactionLogic };
var request = new BasicRequest {Message = message, Dto = message.GetBody()};
var response = new BasicResponse(request);
//userRepo.TryAuthenticate()
service.SessionFactory.GetOrCreateSession(request, response);
var session = service.GetSession();
session.UserName = "******";
var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())};
return results;
};
// Dto Get Operations
mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic));
// Dto Post Operations
mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post));
mqService.RegisterHandler<Transaction>(handlePostTransactions);
mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post));
// Dto Put Opertations
mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic));
mqService.Start();
}
