public BatchController(ITrainingManager iTrainingManager, IBatchManager iBatchManager, IBatchTrainerManager iBatchTrainerManager, IScedhuleTypeManager iScedhuleTypeManager)
{
_iBatchManager = iBatchManager;
_iBatchTrainerManager = iBatchTrainerManager;
_IScedhuleTypeManager = iScedhuleTypeManager;
_iTrainingManager = iTrainingManager;
}
public void Create()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = new Batch
{
BatchName = "37Batch" + DateTime.Now.ToString(),
Branch = new Branch
{
BranchName = "TestBranch",
Institute = new Common.Models.Institute {
InstituteName = "Test Institute"
}
}
};
bool ans = BatchManager.Create(batch);
BatchManager.Save();
Batch batch1 = BatchManager.Find(B => B.BatchName == "37Batch");
string expected = "37Batch";
string actual = batch1.BatchName;
Assert.AreEqual(expected, actual);
}
private Azure(RestClient restClient, string subscriptionId, string tenantId, IAuthenticated authenticated)
{
resourceManager = ResourceManager.Fluent.ResourceManager.Authenticate(restClient).WithSubscription(subscriptionId);
storageManager = StorageManager.Authenticate(restClient, subscriptionId);
computeManager = ComputeManager.Authenticate(restClient, subscriptionId);
networkManager = NetworkManager.Authenticate(restClient, subscriptionId);
batchManager = BatchManager.Authenticate(restClient, subscriptionId);
keyVaultManager = KeyVaultManager.Authenticate(restClient, subscriptionId, tenantId);
trafficManager = TrafficManager.Fluent.TrafficManager.Authenticate(restClient, subscriptionId);
dnsZoneManager = DnsZoneManager.Authenticate(restClient, subscriptionId);
sqlManager = SqlManager.Authenticate(restClient, subscriptionId);
redisManager = RedisManager.Authenticate(restClient, subscriptionId);
cdnManager = CdnManager.Authenticate(restClient, subscriptionId);
appServiceManager = AppServiceManager.Authenticate(restClient, subscriptionId, tenantId);
searchManager = SearchManager.Authenticate(restClient, subscriptionId);
serviceBusManager = ServiceBusManager.Authenticate(restClient, subscriptionId);
containerInstanceManager = ContainerInstanceManager.Authenticate(restClient, subscriptionId);
registryManager = RegistryManager.Authenticate(restClient, subscriptionId);
containerServiceManager = ContainerServiceManager.Authenticate(restClient, subscriptionId);
cosmosDBManager = CosmosDBManager.Authenticate(restClient, subscriptionId);
authorizationManager = AuthorizationManager.Authenticate(restClient, subscriptionId);
msiManager = MsiManager.Authenticate(restClient, subscriptionId);
batchAIManager = BatchAIManager.Authenticate(restClient, subscriptionId);
monitorManager = MonitorManager.Authenticate(restClient, subscriptionId);
eventHubManager = EventHubManager.Authenticate(restClient, subscriptionId);
SubscriptionId = subscriptionId;
this.authenticated = authenticated;
}
/// <summary>
/// Initializes a new instance of the <see cref="Migration"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="scriptExecutor">The script executor.</param>
/// <param name="auditLog">The audit log.</param>
/// <param name="batchManager">The script batch manager.</param>
/// <param name="initializationScriptProvider">The script provider for scripts to run when initializing the database.</param>
/// <param name="migrationScriptProvider">The script provider for scripts to run during migrations.</param>
internal Migration(IConnectionFactory connectionFactory, IScriptExecutor scriptExecutor, IAuditor auditLog, IBatchManager batchManager, IScriptProvider initializationScriptProvider, IScriptProvider migrationScriptProvider)
{
this.connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
this.scriptExecutor = scriptExecutor ?? throw new ArgumentNullException(nameof(scriptExecutor));
this.auditLog = auditLog ?? throw new ArgumentNullException(nameof(auditLog));
this.batchManager = batchManager ?? throw new ArgumentNullException(nameof(batchManager));
this.initializationScriptProvider = initializationScriptProvider ?? throw new ArgumentNullException(nameof(initializationScriptProvider));
this.migrationScriptProvider = migrationScriptProvider ?? throw new ArgumentNullException(nameof(migrationScriptProvider));
}
public OrdersProducerController(
IOrderHandler orderHandler,
IBatchManager batchManager,
ILogger <OrdersController> logger)
{
this.orderHandler = orderHandler;
this.batchManager = batchManager;
this.logger = logger;
}
public static MessageResult LockBatch(IUnitOfWork db,
IBatchManager batchManager,
long batchId,
DateTime?when)
{
batchManager.LockBatch(db, batchId, when);
return(MessageResult.Success());
}
/**
* /// Sets the batch file to use for this recognition
*
* /// @param batchFile the name of the batch file
* /// @throws IOException if the file could not be opened or read.
*/
public void setBatchFile(String batchFile)
{
//if (usePooledBatchManager)
//{
// batchManager = new PooledBatchManager(batchFile, skip);
//}
//else
{
batchManager = new SimpleBatchManager(batchFile, skip, whichBatch,
totalBatches);
}
}
public void GetAll()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
List <Batch> list = BatchManager.GetAll();
foreach (Batch batch in list)
{
Console.WriteLine("Ashan Tharuka : " + batch.BatchId);
}
}
public void Find()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch1 = BatchManager.Find(B => B.BatchId == 92);
string expected = "38Batch";
string actual = batch1.BatchName;
Assert.AreEqual(expected, actual);
}
public void FindById()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch1 = BatchManager.FindById(93);
int expected = 93;
int actual = batch1.BatchId;
Assert.AreEqual(expected, actual);
}
public bool Update(ApiBatch apiBatch)
{
IBatchManager batchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = new Batch
{
ID = apiBatch.ID,
Date = apiBatch.Date,
Qty = apiBatch.Qty,
UnitPrice = apiBatch.UnitPrice,
ItemID = apiBatch.ItemID,
SupplierID = apiBatch.SupplierID,
CustomerID = apiBatch.CustomerID
};
return(batchManager.UpdateBatch(batch));
}
public void Delete()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = BatchManager.Find(B => B.BatchId == 115);
bool ans = BatchManager.Delete(batch);
BatchManager.Save();
bool expected = true;
bool actual = ans;
Assert.AreEqual(expected, actual);
}
public bool Update(ApiBatch apiBatch)
{
//string id = User.Identity.Name;
IBatchManager batchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = new Batch
{
ID = apiBatch.ID,
Date = apiBatch.Date,
Qty = apiBatch.Qty,
UnitPrice = apiBatch.UnitPrice,
ItemID = apiBatch.ItemID,
SupplierID = apiBatch.SupplierID,
CustomerID = Helper.getCustID()
};
return(batchManager.UpdateBatch(batch));
}
public ApiBatch Get(int ID)
{
IBatchManager batchManager = UnityResolver.Resolve <IBatchManager>();
Batch batchModel = batchManager.FindBatchByID(ID);
string id = User.Identity.Name;
ApiBatch batch = new ApiBatch
{
ID = batchModel.ID,
Date = batchModel.Date,
Qty = batchModel.Qty,
UnitPrice = batchModel.UnitPrice,
ItemID = batchModel.ItemID,
SupplierID = batchModel.SupplierID
};
return(batch);
}
public static MessageResult RemoveFromBatch(IUnitOfWork db,
ILogService log,
ISystemActionService systemAction,
IOrderHistoryService orderHistoryService,
IBatchManager batchManager,
long batchId,
long orderId,
long?by)
{
var batch = db.OrderBatches.GetAsDto(batchId);
var order = db.Orders.GetAll().FirstOrDefault(o => o.Id == orderId);
if (batch.IsClosed && !batchManager.CanBeRemovedFromBatch(order))
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Batch was closed"));
}
}
if (batch.IsLocked)
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Batch was locked"));
}
}
if (order != null)
{
var previoudBatchId = order.BatchId;
order.BatchId = null;
batchManager.CheckRemovedOrder(db, log, systemAction, order, null, by);
db.Commit();
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, previoudBatchId, batch.Name, null, null, by);
return(MessageResult.Success());
}
return(MessageResult.Error("No order"));
}
public void Update()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = BatchManager.FindById(91);
batch.BatchName = "38Batch" + DateTime.Now.ToString();
bool isUpdate = BatchManager.Update(batch);
BatchManager.Save();
Batch batch1 = BatchManager.FindById(93);
string expected = "38Batch";
string actual = batch1.BatchName;
Assert.AreEqual(expected, actual);
}
public LabelAutoBuyService(IDbFactory dbFactory,
ILogService log,
ITime time,
IBatchManager batchManager,
ILabelBatchService labelBatchService,
ISystemActionService actionService,
IEmailService emailService,
IWeightService weightService,
long companyId)
{
_dbFactory = dbFactory;
_log = log;
_time = time;
_batchManager = batchManager;
_labelBatchService = labelBatchService;
_actionService = actionService;
_emailService = emailService;
_companyId = companyId;
_weightService = weightService;
}
public LabelBatchService(IDbFactory dbFactory,
ISystemActionService actionService,
ILogService log,
ITime time,
IWeightService weightService,
IServiceFactory serviceFactory,
IEmailService emailService,
IBatchManager batchManager,
IFileMaker pdfMaker,
IAddressService addressService,
IOrderHistoryService orderHistoryService,
string defaultCustomType,
string labelDirectory,
string reserveDirectory,
string templateDirectory,
Config config,
bool isSampleMode)
{
_dbFactory = dbFactory;
_actionService = actionService;
_log = log;
_time = time;
_weightService = weightService;
_serviceFactory = serviceFactory;
_emailService = emailService;
_batchManager = batchManager;
_pdfMaker = pdfMaker;
_addressService = addressService;
_orderHistoryService = orderHistoryService;
_defaultCustomType = defaultCustomType;
_labelDirectory = labelDirectory;
_reserveDirectory = reserveDirectory;
_templateDirectory = templateDirectory;
_config = config;
_isSampleMode = isSampleMode;
}
public static MessageResult CreateBatch(IUnitOfWork db,
IBatchManager batchManager,
string orderIds,
string batchName,
DateTime when,
long?by)
{
if (!string.IsNullOrEmpty(orderIds))
{
var stringOrderIdList = orderIds.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var orderIdList = stringOrderIdList.Select(long.Parse).ToList();
var batchId = batchManager.CreateBatch(db,
BatchType.User,
batchName,
orderIdList,
when,
by);
return(MessageResult.Success("", batchId.ToString()));
}
return(MessageResult.Error("Order list is empty"));
}
public List <ApiBatch> GetList()
{
string id = User.Identity.Name;
IBatchManager batchManager = UnityResolver.Resolve <IBatchManager>();
List <Batch> batchModelList = batchManager.GetAllBatches();
List <ApiBatch> batchList = new List <ApiBatch>();
foreach (Batch batchModel in batchModelList)
{
ApiBatch batch = new ApiBatch
{
ID = batchModel.ID,
Date = batchModel.Date,
Qty = batchModel.Qty,
UnitPrice = batchModel.UnitPrice,
ItemID = batchModel.ItemID,
SupplierID = batchModel.SupplierID
};
batchList.Add(batch);
}
return(batchList);
}
public BatchesController(IBatchManager iBatchManager)
{
_iBatchManager = iBatchManager;
}
/// <summary> /// Set the script file batch manager. This is usually set by an extension method supplied by the database specific package. /// </summary> /// <param name="batchManager">The script batch manager.</param> public void SetBatchManager(IBatchManager batchManager) => this.batchManager = batchManager ?? throw new ArgumentNullException(nameof(batchManager));
public static MessageResult RemoveMultipleFromBatch(IUnitOfWork db,
ILogService log,
ISystemActionService systemAction,
IOrderHistoryService orderHistoryService,
IBatchManager batchManager,
long batchId,
string orderIds,
long?toBatchId,
bool?removeOnHold)
{
var by = AccessManager.UserId;
var wasChanged = false;
var hasClosed = false;
var fromBatch = db.OrderBatches.GetAsDto(batchId);
OrderBatchDTO toBatch = null;
if (toBatchId.HasValue)
{
toBatch = db.OrderBatches.GetAsDto(toBatchId.Value);
}
if (fromBatch.IsClosed || (toBatch != null && toBatch.IsClosed))
{
if (!AccessManager.CanEditSystemInfo() && !AccessManager.IsAdmin)
{
hasClosed = true;
}
}
if (fromBatch.IsLocked || (toBatch != null && toBatch.IsLocked))
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Source or distination batch was locked"));
}
}
var orders = db.Orders.GetFiltered(o => o.BatchId == batchId);
if (!string.IsNullOrEmpty(orderIds) && !removeOnHold.HasValue)
{
var stringOrderIdList = orderIds.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var orderIdList = stringOrderIdList.Select(long.Parse).ToList();
foreach (var orderId in orderIdList)
{
var order = orders.FirstOrDefault(o => o.Id == orderId);
if (order != null)
{
if (!hasClosed || batchManager.CanBeRemovedFromBatch(order) || AccessManager.IsAdmin)
{
order.BatchId = toBatchId;
batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);
wasChanged = true;
}
}
}
}
else if (removeOnHold.HasValue && removeOnHold.Value)
{
var onHoldOrders = orders.Where(o => o.OnHold).ToList();
foreach (var order in onHoldOrders)
{
if (!hasClosed || batchManager.CanBeRemovedFromBatch(order))
{
order.BatchId = toBatchId;
batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);
wasChanged = true;
}
}
}
db.Commit();
if (!wasChanged && hasClosed)
{
return(MessageResult.Error("Source or distination batch was closed"));
}
if (!wasChanged)
{
return(MessageResult.Error("Order list is empty"));
}
return(MessageResult.Success());
}
/// <inheritdoc/>
public async Task ExecuteAsync(DbConnection connection, IEnumerable <IScript> scripts, IBatchManager batchManager, IAuditor auditLog, CancellationToken cancellationToken)
{
Log.Trace($"Begin {nameof(TransactionExecutor)}.{nameof(this.ExecuteAsync)}");
using var transaction = connection.BeginTransaction();
try
{
foreach (var script in scripts)
{
Log.Info($"Executing migration script {script.ScriptName}, Checksum: {script.Checksum}");
foreach (var commandText in batchManager.Split(script))
{
if (string.IsNullOrWhiteSpace(commandText))
{
continue;
}
Log.Debug(commandText);
using var command = connection.CreateCommand();
command.Transaction = transaction;
command.CommandText = commandText;
command.CommandType = System.Data.CommandType.Text;
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
}
}
await auditLog.StoreEntriesAsync(connection, transaction, scripts, cancellationToken).ConfigureAwait(false);
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
Log.Trace($"End {nameof(TransactionExecutor)}.{nameof(this.ExecuteAsync)}");
}
public TasksController(ITestFileQueue fileQueue, ITestFileResultFactory testFileResultFactory, IBatchManager batchManager)
{
_fileQueue = fileQueue;
_testFileResultFactory = testFileResultFactory;
_batchManager = batchManager;
}
