public static void ReleaseDocs(List <Document> list)
{
ReceiptEntry graph = PXGraph.CreateInstance <ReceiptEntry>();
foreach (Document doc in list)
{
graph.Clear();
graph.Receipts.Current = graph.Receipts.Search <Document.docNbr>(doc.DocNbr, doc.DocType);
foreach (DocTransaction line in graph.ReceiptTransactions.Select())
{
ProductQty productQty = new ProductQty();
productQty.ProductID = line.ProductID;
if (doc.DocType == DocTypes.Recpt)
{
productQty.AvailQty = line.TranQty * line.ConversionFactor;
SupplierData suppData = new SupplierData();
suppData.SupplierID = doc.SupplierID;
suppData.ProductID = line.ProductID;
suppData.LastPurchaseDate = doc.DocDate;
suppData.LastSupplierPrice = line.UnitPrice;
suppData.ConversionFactor = line.ConversionFactor;
suppData.SupplierUnit = line.Unit;
graph.SupplierRecords.Insert(suppData);
}
else
{
productQty.AvailQty = -(line.TranQty * line.ConversionFactor);
}
graph.Stock.Insert(productQty);
}
doc.Released = true;
graph.Receipts.Update(doc);
graph.Persist();
}
}
public async Task <Result <AccommodationDuplicateReportInfo> > Get(int reportId, string languageCode)
{
var report = await _context.AccommodationDuplicateReports.SingleOrDefaultAsync(r => r.Id == reportId);
if (report == default)
{
return(Result.Failure <AccommodationDuplicateReportInfo>("Could not find a report"));
}
var accommodations = new List <SupplierData <Accommodation> >(report.Accommodations.Count);
foreach (var supplierAccommodationId in report.Accommodations)
{
var(_, isFailure, accommodationDetails, result) = await _supplierConnectorManager
.Get(supplierAccommodationId.Supplier)
.GetAccommodation(supplierAccommodationId.Id, languageCode);
if (isFailure)
{
return(Result.Failure <AccommodationDuplicateReportInfo>($"Could not find accommodation: {result.Detail}"));
}
accommodations.Add(SupplierData.Create(supplierAccommodationId.Supplier, accommodationDetails));
}
return(new AccommodationDuplicateReportInfo(report.Id, report.Created, report.ApprovalState, accommodations));
}
private List <SpendDetail> GetSpendDetails(SupplierData supplier)
{
var serviceType = supplier.IsExternal ? InvoiceServiceType.External : InvoiceServiceType.Internal;
try
{
List <SpendDetail> summary = null;
policy.Execute(() =>
{
summary = invoiceServiceStrategy.GetService(serviceType)
.GetSpendDetails(supplier.Id)?.ToList();
});
return(summary);
}
catch (Exception ex)
{
if (ex is BrokenCircuitException ||
ex is ExternalInvoiceServiceException)
{
return(invoiceServiceStrategy.GetService(InvoiceServiceType.Failover)
.GetSpendDetails(supplier.Id)
.ToList());
}
throw ex;
}
}
public void DeleteSupplier(SupplierData data)
{
string sql;
SqlCommand cmd;
sql = "DECLARE @adressID AS INT "
+ "SET @adressID = ( "
+ " SELECT a.adress_id "
+ " FROM suppliers s "
+ " LEFT JOIN supplieradress sa ON s.supplier_id = sa.fk_supplier_id "
+ " LEFT JOIN adresses a ON a.adress_id = sa.fk_adress_id "
+ " WHERE s.supplier_id = sa.fk_supplier_id "
+ " ); "
+ "DELETE FROM adresses WHERE adress_id = @adressID; "
+ "DELETE FROM suppliers WHERE supplier_id = @supplierID; "
+ "DELETE FROM supplieradress WHERE fk_adress_id = @adressID; ";
cmd = new SqlCommand(sql);
cmd.Parameters.Add("@supplierID", SqlDbType.Int).Value = data.ID;
using (SqlConnection conn = new SqlConnection(DBCONNECTION))
{
conn.Open();
cmd.Connection = conn;
cmd.ExecuteNonQuery();
}
}
public async Task <Result <SupplierData <AccommodationAvailability>, ProblemDetails> > GetProviderAvailability(Guid searchId,
Guid resultId,
Suppliers supplier,
string accommodationId, string availabilityId, AgentContext agent,
string languageCode)
{
return(await ExecuteRequest()
.Bind(ConvertCurrencies)
.Map(ApplyMarkups)
.Map(AddProviderData)
.Tap(SaveToCache));
Task SaveToCache(SupplierData <AccommodationAvailability> details) => _roomSelectionStorage.SaveResult(searchId, resultId, details.Data, details.Source);
Task <Result <AccommodationAvailability, ProblemDetails> > ExecuteRequest()
=> _supplierConnectorManager.Get(supplier).GetAvailability(availabilityId, accommodationId, languageCode);
Task <Result <AccommodationAvailability, ProblemDetails> > ConvertCurrencies(AccommodationAvailability availabilityDetails)
=> _priceProcessor.ConvertCurrencies(agent, availabilityDetails, AvailabilityResultsExtensions.ProcessPrices, AvailabilityResultsExtensions.GetCurrency);
Task <DataWithMarkup <AccommodationAvailability> > ApplyMarkups(AccommodationAvailability response)
=> _priceProcessor.ApplyMarkups(agent, response, AvailabilityResultsExtensions.ProcessPrices);
SupplierData <AccommodationAvailability> AddProviderData(DataWithMarkup <AccommodationAvailability> availabilityDetails)
=> SupplierData.Create(supplier, availabilityDetails.Data);
}
public ActionResult EditSupplier(int sid)
{
Supplier sup = SupplierData.GetSupplierById(sid);
ViewBag.sup = sup;
return(View());
}
/// <summary>
/// Creates a connection using token.
/// </summary>
/// <param name="companyId">Company context</param>
/// <param name="token">The predefined token from Visma.net</param>
/// <param name="branchId">Branch ID to work with in the Visma.net Company (optional)</param>
public VismaNet(int companyId, string token, int branchId = 0)
{
if (string.IsNullOrEmpty(token))
{
throw new InvalidArgumentsException("Token is missing");
}
Auth = new VismaNetAuthorization
{
Token = token,
CompanyId = companyId,
BranchId = branchId
};
Customers = new CustomerData(Auth);
CustomerInvoices = new CustomerInvoiceData(Auth);
Suppliers = new SupplierData(Auth);
SupplierInvoices = new SupplierInvoiceData(Auth);
CashSales = new CashSaleData(Auth);
CustomerDocuments = new CustomerDocumentData(Auth);
Dimensions = new DimensionData(Auth);
Inventory = new InventoryData(Auth);
JournalTransactions = new JournalTransactionData(Auth);
Accounts = new FinAccountData(Auth);
Employee = new EmployeeData(Auth);
CreditNote = new CreditNoteData(Auth);
Shipments = new ShipmentData(Auth);
Contacts = new ContactData(Auth);
Projects = new ProjectData(Auth);
SalesOrder = new SalesOrderData(Auth);
}
public IActionResult Edit(int id, [Bind("Id,Name,ApiUrl")] SupplierData supplierData)
{
if (id != supplierData.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try {
var editSuccessfully = _SupplierRepo.Update(supplierData);
if (!editSuccessfully)
{
throw new InvalidOperationException(
$"Cannot update supplier with id {supplierData.Id}");
}
_Logger.LogInformation($"Successfully edited supplier with id {supplierData.Id}");
} catch (InvalidOperationException e) {
ModelState.AddModelError(String.Empty, "Something went wrong, sorry");
_Logger.LogError(e.Message);
return(View(supplierData));
}
return(RedirectToAction(nameof(Index)));
}
return(View(supplierData));
}
private void AddSupplierExecuted(object obj)
{
SupplierData data = new SupplierData(null, obj as string, null, null, null, null, null);
SupplierList.Add(data);
_database.InsertSupplier(data);
}
public SupplierData GetSupplierData()
{
SupplierData data = new SupplierData();
data.information = "Supplier information";
return(data);
}
public UpdateSelectedSupplierWindowViewModel(SupplierData SupplierSelect, UserData UserList)
{
UserInfo = new UserData();
UserInfo = UserList;
LoadSelected(SupplierSelect);
Updatecommand = new DelegateCommand <object>(Update);
}
public Task Set(Guid searchId, Guid resultId, Guid roomContractSetId, DataWithMarkup <RoomContractSetAvailability> availability,
Suppliers supplier)
{
var key = BuildKey(searchId, resultId, roomContractSetId);
var dataToSave = SupplierData.Create(supplier, availability);
return(_doubleFlow.SetAsync(key, dataToSave, CacheExpirationTime));
}
public ActionResult UpdateSupplierInfo(Supplier sup)
{
if (sup != null)
{
SupplierData.UpdateSupplier(sup);
}
return(RedirectToAction("ManageSupplier"));
}
/////////////////////////////////////////////////////////////////////Manage Suppliers
public ActionResult ManageSupplier()
{
List <Supplier> slist = new List <Supplier>();
slist = SupplierData.FindAllSupplier();
ViewBag.slist = slist;
return(View());
}
public void ShouldReturnFailoverDataOnExternalExcpetion()
{
// arrange
var expectedSupplier = new SupplierData()
{
Id = 1,
IsExternal = true,
Name = "Test External Suppliing Co",
};
var expectedYears = new List <SpendDetail>()
{
new SpendDetail()
{
Year = 2018, TotalSpend = 1200
},
new SpendDetail()
{
Year = 2017, TotalSpend = 2400
},
};
// external invoice service throws exception
var mockExternalInvoiceService = new Mock <IInvoiceService>();
mockExternalInvoiceService.Setup(svc => svc.GetSpendDetails(1))
.Throws(new ExternalInvoiceServiceException());
var mockFailoverInvoiceService = new Mock <IInvoiceService>();
mockFailoverInvoiceService.Setup(svc => svc.GetSpendDetails(1))
.Returns(expectedYears);
var strategyMapping = new Dictionary <InvoiceServiceType, IInvoiceService>()
{
{ InvoiceServiceType.External, mockExternalInvoiceService.Object },
{ InvoiceServiceType.Failover, mockFailoverInvoiceService.Object }
};
var instance = GetInstance(new[] { expectedSupplier }, strategyMapping);
// act
var actual = instance.GetTotalSpend(1);
// assert
Assert.IsNotNull(actual);
Assert.AreEqual(expectedSupplier.Name, actual.Name);
Assert.AreEqual(expectedYears.Count, actual.Years.Count);
var year2018 = actual.Years.FirstOrDefault(y => y.Year == 2018);
Assert.AreEqual(year2018.TotalSpend, expectedYears[0].TotalSpend);
var year2017 = actual.Years.FirstOrDefault(y => y.Year == 2017);
Assert.AreEqual(year2017.TotalSpend, expectedYears[1].TotalSpend);
}
public IActionResult CreateSupplier([FromBody] SupplierData supplierData)
{
if (ModelState.IsValid)
{
Supplier supplier = supplierData.Supplier;
context.Suppliers.Add(supplier);
context.SaveChanges();
return(Ok(supplier.SupplierId));
}
return(BadRequest(ModelState));
}
public static string GetSupplierName(int id)
{
try
{
return(SupplierData.GetSupplierNameByID(id));
}
catch (NullReferenceException)
{
return(null);
}
}
private void supplierbtn_Click(object sender, EventArgs e)
{
SupplierData supp = new SupplierData();
DataTable event_dt = new DataTable();
event_dt = supp.showSupplier();
BindingSource b_source = new BindingSource();
b_source.DataSource = event_dt;
dataGridView3.DataSource = b_source;
}
public IActionResult ReplaceSupplier(long id, [FromBody] SupplierData sData)
{
if (ModelState.IsValid)
{
var s = sData.Supplier;
s.SupplierId = id;
context.Update(s);
context.SaveChanges();
return(Ok());
}
return(BadRequest(ModelState));
}
public ActionResult Edit(SupplierDataModel model)
{
if (ModelState.IsValid)
{
SupplierData goodsData = model.MapTo <SupplierDataModel, SupplierData>();
_supplierDataService.Update(goodsData);
SuccessNotification($"{_localizationService.GetResource("UpdateSuccess") + model.SupplierName}");
return(RedirectToAction("Index"));
}
model.SupplierTypeList = _commonController.GetSupplierList();
return(View(model));
}
public ActionResult Add(SupplierDataModel model)
{
if (ModelState.IsValid)
{
SupplierData Goods = model.MapTo <SupplierDataModel, SupplierData>();
_supplierDataService.Insert(Goods);
return(RedirectToAction("Index"));
}
model.SupplierTypeList = _commonController.GetSupplierTypeList();
return(View(model));
}
public IActionResult UpdateSupplier(long id, [FromBody] SupplierData supplierData)
{
if (ModelState.IsValid)
{
Supplier supplier = supplierData.Supplier;
supplier.SupplierId = id;
context.Suppliers.Update(supplier);
context.SaveChanges();
return(Ok());
}
return(BadRequest(ModelState));
}
/// <summary>
/// Creates a connection using token.
/// </summary>
/// <param name="companyId">Company context</param>
/// <param name="token">The predefined token from Visma.net</param>
/// <param name="branchId">Branch ID to work with in the Visma.net Company (optional)</param>
public VismaNet(int companyId, string token, int branchId = 0)
{
if (string.IsNullOrEmpty(token))
{
throw new InvalidArgumentsException("Token is missing");
}
Auth = new VismaNetAuthorization
{
Token = token,
CompanyId = companyId,
BranchId = branchId
};
Attribute = new AttributeData(Auth);
Customer = new CustomerData(Auth);
Currency = new CurrencyData(Auth);
CustomerInvoice = new CustomerInvoiceData(Auth);
Supplier = new SupplierData(Auth);
SupplierInvoice = new SupplierInvoiceData(Auth);
CashSale = new CashSaleData(Auth);
CustomerDocument = new CustomerDocumentData(Auth);
Dimension = new DimensionData(Auth);
Discount = new DiscountData(Auth);
Inventory = new InventoryData(Auth);
JournalTransaction = new JournalTransactionData(Auth);
GeneralLedgerTransaction = new GeneralLedgerTransactionData(Auth);
GeneralLedgerBalance = new GeneralLedgerBalanceData(Auth);
Account = new FinAccountData(Auth);
FinancialPeriod = new FinancialPeriodData(Auth);
Employee = new EmployeeData(Auth);
Shipment = new ShipmentData(Auth);
Contact = new ContactData(Auth);
Project = new ProjectData(Auth);
#pragma warning disable CS0618 // Type or member is obsolete
SalesOrder = new SalesOrderData(Auth);
#pragma warning restore CS0618 // Type or member is obsolete
Branch = new BranchData(Auth);
Warehouse = new WarehouseData(Auth);
Location = new LocationData(Auth);
Subaccount = new SubaccountData(Auth);
CustomerPayment = new CustomerPaymentData(Auth);
Dynamic = new VismaNetDynamicEndpoint(null, Auth);
Resources = new VismaNetDynamicEndpoint(null, Auth, true);
SupplierDocument = new SupplierDocumentData(Auth);
InventoryIssue = new InventoryIssueData(Auth);
InventoryReceipt = new InventoryReceiptData(Auth);
PurchaseReceipt = new PurchaseReceiptData(Auth);
CustomerSalesPrice = new CustomerSalesPriceData(Auth);
CustomerCreditNote = new CustomerCreditNoteData(Auth);
PurchaseOrder = new PurchaseOrderData(Auth);
CashTransaction = new CashTransactionData(Auth);
}
static void DumpSupplier(SupplierData supplier)
{
if (supplier != null)
{
Console.WriteLine("Id: " + supplier.Id);
Console.WriteLine("Name: " + supplier.Name);
}
else
{
Console.WriteLine("(null)");
}
Console.WriteLine();
}
public IActionResult CreateSupplier(SupplierData sData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Supplier s = sData.Supplier;
_context.Add(s);
_context.SaveChanges();
return(Ok(s.SupplierId));
}
public IActionResult CreateSupplier([FromBody] SupplierData newSupplier)
{
if (ModelState.IsValid)
{
Supplier s = newSupplier.Supplier;
_context.Add(s);
_context.SaveChanges();
return(Ok(s.SupplierId));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> ReplaceSupplier(long id, [FromBody] SupplierData sdata)
{
if (ModelState.IsValid)
{
var s = sdata.Supplier;
s.SupplierId = id;
_context.Update(s);
await _context.SaveChangesAsync();
return(Ok());
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> CreateSupplier([FromBody] SupplierData sdata)
{
if (ModelState.IsValid)
{
Supplier s = sdata.Supplier;
await _context.AddAsync(s);
await _context.SaveChangesAsync();
return(Ok(s.SupplierId));
}
return(BadRequest(ModelState));
}
public void ShouldReturnCorrectInternalTotalSpend()
{
// arrange
var expectedSupplier = new SupplierData()
{
Id = 1,
IsExternal = false,
Name = "Test Internal Suppliing Co",
};
var expectedYears = new List <SpendDetail>()
{
new SpendDetail()
{
Year = 2018, TotalSpend = 100
},
new SpendDetail()
{
Year = 2017, TotalSpend = 500
},
};
var mockInvoiceService = new Mock <IInvoiceService>();
mockInvoiceService.Setup(svc => svc.GetSpendDetails(1))
.Returns(expectedYears);
var strategyMapping = new Dictionary <InvoiceServiceType, IInvoiceService>()
{
{ InvoiceServiceType.Internal, mockInvoiceService.Object }
};
var instance = GetInstance(new[] { expectedSupplier }, strategyMapping);
// act
var actual = instance.GetTotalSpend(1);
// assert
Assert.IsNotNull(actual);
Assert.AreEqual(expectedSupplier.Name, actual.Name);
Assert.AreEqual(expectedYears.Count, actual.Years.Count);
var year2018 = actual.Years.FirstOrDefault(y => y.Year == 2018);
Assert.AreEqual(year2018.TotalSpend, expectedYears[0].TotalSpend);
var year2017 = actual.Years.FirstOrDefault(y => y.Year == 2017);
Assert.AreEqual(year2017.TotalSpend, expectedYears[1].TotalSpend);
}
public void Update(SupplierData SupplierData)
{
var sql = $@"update SupplierData set
SupplierName=@SupplierName,
CompanyName=@CompanyName,
Contacts=@Contacts,
SupplierType=@SupplierType,
Area=@Area,
Address=@Address,
Phone=@Phone,
Telephone=@Telephone,
Arrears=@Arrears,
RepaymentDate=@RepaymentDate,
Banks=@Banks,
AccountName=@AccountName,
BankAccount=@BankAccount,
TaxIdentificationNumber=@TaxIdentificationNumber,
Seq=@Seq,
Remarks1=@Remarks1,
Remarks2=@Remarks2,
Remarks3=@Remarks3,
Remarks4=@Remarks4
where ID=@ID ";
_context.Execute(sql, new
{
ID = SupplierData.ID,
Contacts = SupplierData.Contacts,
SupplierName = SupplierData.SupplierName,
CompanyName = SupplierData.CompanyName,
SupplierType = SupplierData.SupplierType,
Address = SupplierData.Address,
Area = SupplierData.Area,
Phone = SupplierData.Phone,
Telephone = SupplierData.Telephone,
Arrears = SupplierData.Arrears,
RepaymentDate = SupplierData.RepaymentDate,
Banks = SupplierData.Banks,
AccountName = SupplierData.AccountName,
BankAccount = SupplierData.BankAccount,
TaxIdentificationNumber = SupplierData.TaxIdentificationNumber,
Seq = SupplierData.Seq,
Remarks1 = SupplierData.Remarks1,
Remarks2 = SupplierData.Remarks2,
Remarks3 = SupplierData.Remarks3,
Remarks4 = SupplierData.Remarks4
});
}
