public StaticDataManager(IStaticDataLoader staticDataLoader, ILoaderRepository loaderRepository,
IStaticDataRepository staticDataRepository)
{
_loader = (StaticDataLoader)staticDataLoader;
_loaderRepository = (LoaderRepository)loaderRepository;
_staticDataRepository = (StaticDataRepository)staticDataRepository;
}
public BookmarkViewModel(BookmarkSection personalBookmarks, BookmarkSection corpBookmarks, string system, IStaticDataRepository repository)
{
PersonalBookmarks = personalBookmarks;
CorpBookmarks = corpBookmarks;
System = system;
_repository = repository;
}
public ExcelMappingRepository(telebilling_v01Context dbTeleBilling_V01Context, IMapper mapper, IStringConstant iStringConstant
, ILogManagement ilogManagement, IStaticDataRepository iStaticRepository)
{
_dbTeleBilling_V01Context = dbTeleBilling_V01Context;
_iStringConstant = iStringConstant;
_mapper = mapper;
_iLogManagement = ilogManagement;
_iStaticRepository = iStaticRepository;
}
public async Task LoadCompanyStaticDataAsConstantAsync(IStaticDataRepository staticDataRepo)
{
var remarks = await staticDataRepo.LoadRemarkAsync();
foreach (Remark remark in remarks)
{
mcalcEnggine.AddConstant(remark.Code, remark.Value);
}
}
public Shared.Common.DbResponse InsertErrorLog(Shared.Common.ErrorLogsCommon log)
{
if (null == repo)
{
repo = new StaticDataRepository();
}
return(repo.InsertErrorLog(log));
}
public CustomerController(IMapper mapper,
ICustomerRepository customerRepository,
IUnitOfWork unitOfWork,
IStaticDataRepository staticDataRepository)
{
this.unitOfWork = unitOfWork;
this.customerRepository = customerRepository;
this.staticDataRepository = staticDataRepository;
this.mapper = mapper;
}
/// <summary>
///
/// </summary>
/// <param name="owner"></param>
/// <param name="loadBalancer"></param>
/// <param name="staticDataRepository"></param>
/// <param name="log"></param>
/// <param name="schema"> </param>
/// <param name="systemType"></param>
protected Loader(IEntity owner, IDatabaseLoadBalancer loadBalancer,
IStaticDataRepository staticDataRepository, ILogWrapper log, string schema,
Globals.SystemTypes systemType)
: base(owner, loadBalancer)
{
Repository = (StaticDataRepository)staticDataRepository;
Log = log;
SystemType = systemType;
IdColumn = systemType + "ID";
NameColumn = "DisplayName";
Schema = schema;
_commands = new Dictionary <string, string>();
}
private static async Task <int> FindRemarkIdAsync(IStaticDataRepository staticData, string remarkCode)
{
if (remarkCode == null)
{
return(0);
}
else
{
var listOfRemark = await staticData.LoadRemarkAsync();
var remark = listOfRemark.Where(x => x.Code.ToLower().Equals(remarkCode.ToLower()))
.FirstOrDefault();
if (remark != null)
{
return((int)remark.Value);
}
else
{
return(0);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="owner"></param>
/// <param name="loadBalancer"></param>
/// <param name="staticDataRepository"></param>
/// <param name="log"> </param>
public MudProgLoader([Named("StaticDataLoader")] IEntity owner, IDatabaseLoadBalancer loadBalancer,
IStaticDataRepository staticDataRepository, string schema, ILogWrapper log)
: base(owner, loadBalancer, staticDataRepository, log, schema, Globals.SystemTypes.MudProg)
{
}
public StaticDataController(IStaticDataRepository iStaticDataRepository, IHostingEnvironment hostingEnvironment)
{
_iStaticDataRepository = iStaticDataRepository;
_hostingEnvironment = hostingEnvironment;
}
public AttendanceCalculatorController(IStaticDataRepository staticRepo)
{
mstaticRepo = staticRepo;
}
public StaticDataController(IStaticDataRepository repository)
{
_repository = repository;
}
public CreateMasterTradingAgreementCommandHandler(AppDbContext db, IStaticDataRepository repository)
{
_db = db;
_staticData = repository.GetStaticDataAsync().Result;
}
public StaticDataController(IStaticDataRepository staticDataRepository)
{
_staticDataRepository = staticDataRepository;
}
public StaticDataController(IMapper mapper, IStaticDataRepository staticDataRepository)
{
this.staticDataRepository = staticDataRepository;
this.mapper = mapper;
}
public static async Task <AttendanceData> ToAttendanceDataAsync(this Attendance attendance, IStaticDataRepository staticData)
{
var transformed = new AttendanceData();
if (attendance != null)
{
transformed.DateIn = attendance.DateIn;
transformed.DateOut = attendance.DateOut;
transformed.Remark = await FindRemarkIdAsync(staticData, attendance.Remark);
}
return(transformed);
}
public StaticDataBusiness(StaticDataRepository _repo)
{
repo = _repo;
}
//static DatabaseModel _db = new DatabaseModel();
//public TasksController()
//{
// _tasksRepository = new TasksRepository(_db);
// _staticDataRepository = new StaticDataRepository(_db);
// _usersRepository = new UsersRepository(_db);
//}
public TasksController(ITasksRepository tasksRepository, IStaticDataRepository staticDataRepository, IUsersRepository usersRepository)
{
_tasksRepository = tasksRepository;
_staticDataRepository = staticDataRepository;
_usersRepository = usersRepository;
}
public PathManager(IStaticDataRepository staticDataRepository, IGraphRepository graphRepository)
{
_staticDataRepository = (StaticDataRepository)staticDataRepository;
_graphRepository = (GraphRepository)graphRepository;
}
public CachedStaticDataRepository(IStaticDataRepository repository, ICache cache)
{
_repository = repository;
_cache = cache;
}
public StaticDataProxy(IStaticDataRepository repository) : base()
{
this.staticDataRepository = repository;
}