/// <summary>
/// Word recognized event handler
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _speechRecognition_WordRecognized(object sender, SpeechRecognitionEventArgs e)
{
SynchronizationCommand command = SynchronizationCommand.Ok;
if (Enum.TryParse <SynchronizationCommand>(e.Word, out command))
{
switch (command)
{
case SynchronizationCommand.Ready:
// sent by slave robot, means it is in lift position
// send the start command and wait for confirmation
this.Say(SynchronizationCommand.Start.ToString());
break;
case SynchronizationCommand.Start:
// sent by master robot
// send the confirmation and set the synchronized variable to true
this.Say(SynchronizationCommand.Ok.ToString());
// allow time for the command to be received
Thread.Sleep(1000);
goto case SynchronizationCommand.Ok;
case SynchronizationCommand.Ok:
this._synchronized = true;
break;
}
}
}
public void SynchronizeTest()
{
var webServer = new WebServer("http://mss.alkotorg.com", "manager", "423200");
const int bathSize = 300;
var storageManager = new SqLiteStorageManager();
var unitOfWorkFactory = new SqLiteUnitOfWorkFactory(storageManager);
// Initialization
const string dbScriptFileName = @"\schema.sql";
string databaseScriptFullPath = TestEnvironment.GetApplicationDirectory() + dbScriptFileName;
string databaseFileFullPath = TestEnvironment.GetApplicationDirectory() + @"\storage.sqlite";
var database = storageManager.CreateOrOpenStorage(databaseFileFullPath, databaseScriptFullPath);
var repositoryFactory = new RepositoryFactory(storageManager);
repositoryFactory.RegisterSpecificationTranslator(new CommonTranslator<Customer>())
.RegisterSpecificationTranslator(new ShippingAddressSpecTranslator())
.RegisterSpecificationTranslator(new CommonTranslator<Category>())
.RegisterSpecificationTranslator(new CommonTranslator<PriceList>())
.RegisterSpecificationTranslator(new CommonTranslator<Product>())
.RegisterSpecificationTranslator(new OrderSpecTranslator())
.RegisterSpecificationTranslator(new OrderItemSpecTranslator())
.RegisterSpecificationTranslator(new ProductPriceSpecTranslator())
.RegisterSpecificationTranslator(
new ProductsUnitOfMeasureSpecTranslator())
.RegisterSpecificationTranslator(new RoutePointSpecTranslator())
.RegisterSpecificationTranslator(new RouteSpecTranslator())
.RegisterSpecificationTranslator(
new RoutePointTemplateSpecTranslator())
.RegisterSpecificationTranslator(new RouteTemplateSpecTranslator())
.RegisterSpecificationTranslator(new CommonTranslator<Status>())
.RegisterSpecificationTranslator(new CommonTranslator<UnitOfMeasure>())
.RegisterSpecificationTranslator(new CommonTranslator<Warehouse>());
// Customers synchronization
var customerDtoRepository = new WebRepository<CustomerDto>(webServer);
var customerSqLiteRepository = repositoryFactory.CreateRepository<Customer>();
DtoTranslator<Customer, CustomerDto> customerTranslator =
new CustomerTranslator(repositoryFactory);
var customerSyncCmd =
new SynchronizationCommand<CustomerDto, Customer>(customerDtoRepository,
customerSqLiteRepository,
customerTranslator, unitOfWorkFactory,
bathSize);
customerSyncCmd.Execute();
// Shipping addresses synchronization
var shippingAddressDtoRepository =
new WebRepository<ShippingAddressDto>(webServer);
var shippingAddressSqLiteRepository = repositoryFactory.CreateRepository<ShippingAddress>();
DtoTranslator<ShippingAddress, ShippingAddressDto> shippingAddressdTranslator =
new ShippingAddressdTranslator();
var shippingAddressSyncCmd =
new SynchronizationCommand<ShippingAddressDto, ShippingAddress>(
shippingAddressDtoRepository, shippingAddressSqLiteRepository,
shippingAddressdTranslator, unitOfWorkFactory, bathSize);
shippingAddressSyncCmd.Execute();
// Categories synchronization
var categoriesDtoRepository = new WebRepository<CategoryDto>(webServer);
var categorySqLiteRepository = repositoryFactory.CreateRepository<Category>();
DtoTranslator<Category, CategoryDto> categoriesTranslator = new CategoryTranslator();
var categoriesSyncCmd = new CategotiesSynchronization(categoriesDtoRepository,
categorySqLiteRepository,
categoriesTranslator,
unitOfWorkFactory, bathSize);
categoriesSyncCmd.Execute();
// Statuses synchronization
var statusDtoRepository = new WebRepository<StatusDto>(webServer);
var statusSqLiteRepository = repositoryFactory.CreateRepository<Status>();
DtoTranslator<Status, StatusDto> statusTranslator = new StatusTranslator();
var statusSyncCommand =
new SynchronizationCommand<StatusDto, Status>(statusDtoRepository,
statusSqLiteRepository,
statusTranslator, unitOfWorkFactory,
bathSize);
statusSyncCommand.Execute();
// Warehouses synchronization
var warehouseDtoRepository = new WebRepository<WarehouseDto>(webServer);
var warehouseSqLiteRepository = repositoryFactory.CreateRepository<Warehouse>();
DtoTranslator<Warehouse, WarehouseDto> warehouseTranslator =
new WarehouseTranslator();
var warehouseSyncCommand =
new SynchronizationCommand<WarehouseDto, Warehouse>(warehouseDtoRepository,
warehouseSqLiteRepository,
warehouseTranslator,
unitOfWorkFactory, bathSize);
warehouseSyncCommand.Execute();
// Price lists synchronization
var priceListDtoRepository = new WebRepository<PriceListDto>(webServer);
var priceListSqLiteRepository = repositoryFactory.CreateRepository<PriceList>();
DtoTranslator<PriceList, PriceListDto> priceListTranslator =
new PriceListTranslator(repositoryFactory);
var priceListSyncCommand =
new SynchronizationCommand<PriceListDto, PriceList>(priceListDtoRepository,
priceListSqLiteRepository,
priceListTranslator,
unitOfWorkFactory, bathSize);
priceListSyncCommand.Execute();
// UnitOfMeasures synchronization
var unitOfMeasureDtoRepository =
new WebRepository<UnitOfMeasureDto>(webServer);
var unitOfMeasureSqLiteRepository = repositoryFactory.CreateRepository<UnitOfMeasure>();
DtoTranslator<UnitOfMeasure, UnitOfMeasureDto> unitOfMeasureTranslator =
new UnitOfMeasureTranslator();
var unitOfMeasureSyncCommand =
new SynchronizationCommand<UnitOfMeasureDto, UnitOfMeasure>(
unitOfMeasureDtoRepository, unitOfMeasureSqLiteRepository,
unitOfMeasureTranslator, unitOfWorkFactory, bathSize);
unitOfMeasureSyncCommand.Execute();
// Products synchronization
var productDtoRepository = new WebRepository<ProductDto>(webServer);
var productSqLiteRepository = repositoryFactory.CreateRepository<Product>();
DtoTranslator<Product, ProductDto> productTranslator = new ProductTranslator(repositoryFactory);
var productSyncCommand =
new SynchronizationCommand<ProductDto, Product>(productDtoRepository,
productSqLiteRepository,
productTranslator, unitOfWorkFactory,
bathSize);
productSyncCommand.Execute();
// Product prices synchronization
var productsPriceDtoRepository =
new WebRepository<ProductPriceDto>(webServer);
var productsPriceSqLiteRepository = repositoryFactory.CreateRepository<ProductsPrice>();
DtoTranslator<ProductsPrice, ProductPriceDto> productsPriceTranslator =
new ProductsPriceTranslator();
var productsPricesSyncCommand =
new SynchronizationCommand<ProductPriceDto, ProductsPrice>(
productsPriceDtoRepository, productsPriceSqLiteRepository,
productsPriceTranslator, unitOfWorkFactory, bathSize);
productsPricesSyncCommand.Execute();
// Product units of measure synchronization
var productsUomDtoRepository =
new WebRepository<ProductUnitOfMeasureDto>(webServer);
var productsUnitOfMeasureSqLiteRepository =
repositoryFactory.CreateRepository<ProductsUnitOfMeasure>();
DtoTranslator<ProductsUnitOfMeasure, ProductUnitOfMeasureDto>
productsUnitOfMeasureTranslator = new ProductsUnitOfMeasureTranslator();
var productsUomSyncCommand =
new SynchronizationCommand<ProductUnitOfMeasureDto, ProductsUnitOfMeasure>(
productsUomDtoRepository, productsUnitOfMeasureSqLiteRepository,
productsUnitOfMeasureTranslator, unitOfWorkFactory, bathSize);
productsUomSyncCommand.Execute();
// Route templates synchronization
var routeTemplateDtoRepository =
new WebRepository<RouteTemplateDto>(webServer);
var routeTemplateSqLiteRepository = repositoryFactory.CreateRepository<RouteTemplate>();
DtoTranslator<RouteTemplate, RouteTemplateDto> routeTemplateTranslator =
new RouteTemplateTranslator(repositoryFactory);
var routeTemplateSyncCommand =
new SynchronizationCommand<RouteTemplateDto, RouteTemplate>(
routeTemplateDtoRepository, routeTemplateSqLiteRepository,
routeTemplateTranslator, unitOfWorkFactory, bathSize);
routeTemplateSyncCommand.Execute();
// Route points templates synchronization
var routePointTemplateDtoRepository =
new WebRepository<RoutePointTemplateDto>(webServer);
var routePointTemplateSqLiteRepository =
repositoryFactory.CreateRepository<RoutePointTemplate>();
DtoTranslator<RoutePointTemplate, RoutePointTemplateDto>
routePointTemplateTranslator = new RoutePointTemplateTranslator();
var routePointTemplateSyncCommand =
new SynchronizationCommand<RoutePointTemplateDto, RoutePointTemplate>(
routePointTemplateDtoRepository, routePointTemplateSqLiteRepository,
routePointTemplateTranslator, unitOfWorkFactory, bathSize);
routePointTemplateSyncCommand.Execute();
// Copy result database
File.Copy(databaseFileFullPath, @"\Storage Card\storage.sqlite");
database.Dispose();
}
