// [Fact]
        public async Task Can_create_sale_order()
        {
            var odooClient = new OdooClient(Config);

            var companyResult = await odooClient.GetAsync <CompanyOdooDto>(OdooQuery <CompanyOdooDto> .Create().ById(1));

            companyResult.Succeed.Should().BeTrue();
            var company = companyResult.Value.First();

            var partnerResult = await odooClient.GetAsync <ResPartnerOdooModel>(OdooQuery <ResPartnerOdooModel> .Create().ById(9));

            partnerResult.Succeed.Should().BeTrue();
            var partner = partnerResult.Value.First();

            var productQuery = OdooQuery <ProductProductOdooDto> .Create().ById(41);

            var productsResult = await odooClient.GetAsync <ProductProductOdooDto>(productQuery);

            productsResult.Succeed.Should().BeTrue();
            var product = productsResult.Value.First();



            var dictModel = OdooDictionaryModel.Create(() => new SaleOrderOdooModel
            {
                PricelistId = 17,

                PartnerId         = partner.Id,
                PartnerInvoiceId  = partner.Id,
                PartnerShippingId = partner.Id,

                CompanyId = company.Id,

                DateOrder = DateTime.Now,
            });

            var createResult = await odooClient.CreateAsync(dictModel);

            createResult.Message.Should().BeNullOrEmpty();
            createResult.Succeed.Should().BeTrue();


            var lineModel = OdooDictionaryModel.Create(() => new SaleOrderLineOdooDto()
            {
                OrderId       = createResult.Value,
                Name          = "test line",
                ProductId     = product.Id,
                ProductUomQty = 24,
                PriceUnit     = 15
            });

            var createLineResult = await odooClient.CreateAsync(lineModel);

            createLineResult.Succeed.Should().BeTrue();
        }
        // [Fact]
        public async Task Can_create_product_and_delete_using_object()
        {
            var odooClient = new OdooClient(Config);

            var model = new OdooCreateProduct()
            {
                Name    = "Prod test Kg",
                UomId   = 3,
                UomPoId = 3
            };

            var createResult = await odooClient.CreateAsync(model);

            createResult.Succeed.Should().BeTrue();
            var createdProductId = createResult.Value;

            var query = OdooQuery <ProductProductOdooDto> .Create().ById(createdProductId);

            var product = await odooClient.GetAsync <ProductProductOdooDto>(query);

            product.Succeed.Should().BeTrue();
            product.Value.First().Name.Should().Be(model.Name);

            var deleteProductResult = await odooClient.DeleteAsync(product.Value.First());

            deleteProductResult.Succeed.Should().BeTrue();
            deleteProductResult.Value.Should().BeTrue();
        }
        public async Task Can_Create_customer()
        {
            var name       = "dupa";
            var city       = "dupa";
            var postalCode = "dupa";
            var vatEu      = "test";
            var address    = "dupa";
            var isCompany  = true;

            CompanyTypeResPartnerOdooEnum?test = CompanyTypeResPartnerOdooEnum.Company;

            var model = OdooDictionaryModel.Create(() => new ResPartnerOdooModel()
            {
                Name      = name,
                CountryId = 20,
                City      = city,
                Zip       = postalCode,
                //Vat = vatEu,
                Street      = address,
                CompanyType = test ?? CompanyTypeResPartnerOdooEnum.Individual
            });

            var odooClient = new OdooClient(Config);

            var products = await odooClient.CreateAsync(model);

            products.Succeed.Should().BeTrue();
        }
        // [Fact]
        public async Task Can_create_product_from_dictionary_model()
        {
            var odooClient = new OdooClient(Config);

            var dictModel = OdooDictionaryModel.Create(() => new ProductProductOdooDto
            {
                Name = "test OdooCreateDictionary",
            });

            var dictModel2 = OdooDictionaryModel.Create <ProductProductOdooDto>(x => x.CombinationIndices, "create test");

            var dictModel3 = OdooDictionaryModel.Create <ProductProductOdooDto>(x => x.InvoicePolicy, InvoicingPolicyOdooEnum.DeliveredQuantities);

            dictModel.Add <ProductProductOdooDto>(x => x.CombinationIndices, "sadasd");
            dictModel.Add <ProductProductOdooDto>(x => x.InvoicePolicy, InvoicingPolicyOdooEnum.DeliveredQuantities);

            var createResult = await odooClient.CreateAsync(dictModel);

            createResult.Succeed.Should().BeTrue();
            createResult.Value.Should().BeGreaterThan(0);

            var deleteProductResult = await odooClient.DeleteAsync("product.product", createResult.Value);

            deleteProductResult.Succeed.Should().BeTrue();
            deleteProductResult.Value.Should().BeTrue();
        }
Пример #5
0
        //  [Fact]
        public async Task Can_create_product()
        {
            var odooClient = new OdooClient(TestConfig);

            var model = new OdooCreateProduct()
            {
                Name    = "Prod test Kg",
                UomId   = 3,
                UomPoId = 3,
            };

            var products = await odooClient.CreateAsync(model);

            products.Error.Should().BeNull();
            products.Succeed.Should().BeTrue();
        }
        //[Fact]
        public async Task Can_create_update_delete_product()
        {
            var odooClient = new OdooClient(Config);

            var model = new OdooCreateProduct()
            {
                Name          = "Prod test Kg",
                UomId         = 3,
                UomPoId       = 3,
                InvoicePolicy = InvoicingPolicyOdooEnum.DeliveredQuantities
            };

            var createResult = await odooClient.CreateAsync(model);

            createResult.Succeed.Should().BeTrue();
            var createdProductId = createResult.Value;

            var query = OdooQuery <ProductProductOdooDto> .Create()
                        .Where(x => x.Id, OdooOperator.EqualsTo, createdProductId);

            var products = await odooClient.GetAsync <ProductProductOdooDto>(query);

            products.Succeed.Should().BeTrue();
            products.Value.Length.Should().Be(1);
            products.Value.First().Name.Should().Be(model.Name);

            model.Name += " update";

            var updateProductResult = await odooClient.UpdateAsync(model, createdProductId);

            updateProductResult.Succeed.Should().BeTrue();

            var query2 = OdooQuery <ProductProductOdooDto> .Create()
                         .Where(x => x.Id, OdooOperator.EqualsTo, createdProductId);

            var products2 = await odooClient.GetAsync <ProductProductOdooDto>(query2);

            products2.Succeed.Should().BeTrue();
            products2.Value.Length.Should().Be(1);
            products2.Value.First().Name.Should().Be(model.Name);


            var deleteProductResult = await odooClient.DeleteAsync(model.OdooTableName(), createdProductId);

            deleteProductResult.Succeed.Should().BeTrue();
            deleteProductResult.Value.Should().BeTrue();
        }
        //  [Fact]
        public async Task Can_create_product()
        {
            var odooClient = new OdooClient(Config);

            var model = new OdooCreateProduct()
            {
                Name          = "Prod test Kg",
                UomId         = 3,
                UomPoId       = 3,
                InvoicePolicy = InvoicingPolicyOdooEnum.DeliveredQuantities
            };

            var products = await odooClient.CreateAsync(model);

            products.Error.Should().BeNull();
            products.Succeed.Should().BeTrue();
        }
        //[Fact]
        public async Task Can_create_voucher()
        {
            var odooClient = new OdooClient(Config);

            var model = new OdooVoucherCreateOrUpdate()
            {
                Active              = true,
                Name                = $"GiftCard 123E",
                PromoCode           = "codetest1",
                RuleDateTo          = new DateTime(2021, 1, 1),
                DiscountFixedAmount = 2d,
                DiscountType        = "fixed_amount",
                ProgramType         = "promotion_program"
            };

            var createResult = await odooClient.CreateAsync(model);

            createResult.Succeed.Should().BeTrue();
        }
Пример #9
0
        public async Task Can_create_update_and_delete_product()
        {
            var odooClient = new OdooClient(TestConfig);

            var model = OdooDictionaryModel.Create(() => new ProductProductOdooModel
            {
                Name      = "test name",
                UomId     = 3,
                UomPoId   = 3,
                CompanyId = 1
            });

            var createResult = await odooClient.CreateAsync(model);

            createResult.Error.Should().BeNull();
            createResult.Succeed.Should().BeTrue();

            var query = OdooQuery <ProductProductOdooModel> .Create()
                        .ById(createResult.Value);

            var products = await odooClient.GetAsync <ProductProductOdooModel>(query);

            products.Succeed.Should().BeTrue();
            products.Value.First().CompanyId.Should().Be(1);

            var dict = OdooDictionaryModel.Create(() => new ProductProductOdooModel
            {
                CompanyId = null
            });

            var updateResult = await odooClient.UpdateAsync(dict, createResult.Value);

            updateResult.Succeed.Should().BeTrue();

            var products2 = await odooClient.GetAsync <ProductProductOdooModel>(query);

            products2.Succeed.Should().BeTrue();
            products2.Value.First().CompanyId.Should().BeNull();

            var deleteResult = await odooClient.DeleteAsync(products2.Value.First());

            deleteResult.Succeed.Should().BeTrue();
        }
Пример #10
0
        public async Task Can_create_update_get_and_delete_customer()
        {
            var model = OdooDictionaryModel.Create(() => new ResPartnerOdooModel()
            {
                Name        = "dupa",
                CountryId   = 20,
                City        = "dupa",
                Zip         = "dupa",
                Street      = "dupa",
                CompanyType = CompanyTypeResPartnerOdooEnum.Individual
            });

            var odooClient = new OdooClient(TestConfig);
            var products   = await odooClient.CreateAsync(model);

            products.Succeed.Should().BeTrue();
            products.Value.Should().BePositive();

            model.Add(x => x.Name, "new name");

            var editedCustomer = await odooClient.UpdateAsync(model, products.Value);

            editedCustomer.Succeed.Should().BeTrue();

            var query = new OdooQuery();

            query.Filters.EqualTo("id", products.Value);
            var customers = await odooClient.GetAsync <ResPartnerOdooModel>(query);

            customers.Succeed.Should().BeTrue();
            customers.Value.Length.Should().Be(1);
            customers.Value.First().Name.Should().Be("new name");

            var deleteResult = await odooClient.DeleteAsync(customers.Value.First());

            deleteResult.Succeed.Should().BeTrue();
        }