private void SetControlsState(ContractTemplate row, PXCache sender)
{
Contracts.Cache.AllowInsert = false;
Contracts.Cache.AllowUpdate = false;
Contracts.Cache.AllowDelete = false;
if (row != null)
{
#region Setup Controls for Multi-Currency
PXUIFieldAttribute.SetVisible <ContractTemplate.curyID>(sender, row, IsMultyCurrency);
PXUIFieldAttribute.SetVisible <ContractTemplate.rateTypeID>(sender, row, IsMultyCurrency);
PXUIFieldAttribute.SetVisible <ContractTemplate.allowOverrideCury>(sender, row, IsMultyCurrency);
PXUIFieldAttribute.SetVisible <ContractTemplate.allowOverrideRate>(sender, row, IsMultyCurrency);
#endregion
PXUIFieldAttribute.SetEnabled <ContractTemplate.isContinuous>(sender, row, row.Type == Contract.type.Renewable);
#region Contract Type
PXUIFieldAttribute.SetEnabled <ContractTemplate.autoRenew>(sender, row, row.Type != Contract.type.Unlimited);
PXUIFieldAttribute.SetEnabled <ContractTemplate.duration>(sender, row, row.Type != Contract.type.Unlimited);
PXUIFieldAttribute.SetEnabled <ContractTemplate.durationType>(sender, row, row.Type != Contract.type.Unlimited);
PXUIFieldAttribute.SetEnabled <ContractTemplate.expireDate>(sender, row, row.Type != Contract.type.Unlimited);
PXUIFieldAttribute.SetEnabled <ContractTemplate.isContinuous>(sender, row, row.Type != Contract.type.Unlimited);
PXUIFieldAttribute.SetEnabled <ContractTemplate.refundPeriod>(sender, row, row.Refundable == true);
#endregion
ContractDetail detail = PXSelect <ContractDetail, Where <ContractDetail.contractID, Equal <Current <ContractTemplate.contractID> > > > .SelectWindowed(this, 0, 1);
PXUIFieldAttribute.SetEnabled <ContractTemplate.curyID>(sender, row, detail == null ? true : false);
}
AttributeGroup.Cache.AllowInsert = row.ContractID > 0 || IsCopyPasteContext;
}
public static ContractDetail LoadContractDetail(string nationalId, SqlConnection con)
{
var detail = new ContractDetail();
detail.NationalId = nationalId;
var sql = @"SELECT *
FROM Contract C
WHERE C.ContractId IN
(
SELECT Fk_Contract
FROM ContractIndividual CI
WHERE CI.NationalId = @nationalId
)" ;
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddRange(new[] {
new SqlParameter("@nationalId", nationalId),
});
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
detail.Contracts.Add(LoadContract(reader));
}
}
};
return(detail);
}
public ActionResult Edit(int id)
{
ContractDetail e = repo.Get(id);
//e.NewCategoryFullName = e.CategoryFullName;
return(View(e));
}
private void btnSave_Click(object sender, EventArgs e)
{
ContractDetail _newContract = new ContractDetail();
if (IsEdit == true)
{
_newContract = _db.GetContractById(ContractId);
}
_newContract.CustomerId = CustomerId;
_newContract.BasePrice = Convert.ToDecimal(txtBasePrice.Text);
_newContract.BaseUsers = Convert.ToInt32(txtBaseUsers.Text);
_newContract.CostExtraUser = Convert.ToDecimal(txtCostOfExtraUser.Text);
_newContract.MonthlyCharge = Convert.ToDecimal(txtMonthlyCharge.Text);
_newContract.NoOfUsers = Convert.ToInt32(txtNumberOfUsers.Text);
_newContract.SignOffGoLive = dtSignOffDate.Value;
_newContract.RRARR = Convert.ToDecimal(txtRRARR.Text);
_newContract.databaseID = databaseId;
if (IsEdit == true)
{
_db.SaveContractType(_newContract);
_db.SaveChanges();
MessageBox.Show("Contract has been Update", "Contract Saved", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
else
{
_db.AddToContract(_newContract);
_db.SaveChanges();
MessageBox.Show("Contract has been Created", "Contract Saved", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ContractId,SupportTypeId,ServicePrice,ObjectsId")] ContractDetail contractDetail)
{
if (id != contractDetail.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contractDetail);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContractDetailExists(contractDetail.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ContractId"] = new SelectList(_context.Contract, "Id", "Id", contractDetail.ContractId);
ViewData["ObjectsId"] = new SelectList(_context.Set <Objects>(), "Id", "Floor", contractDetail.ObjectsId);
ViewData["SupportTypeId"] = new SelectList(_context.Set <SupportType>(), "Id", "Defenition", contractDetail.SupportTypeId);
return(View(contractDetail));
}
private void ConfigureContract(ContractDetail detail)
{
detail.DateAcepted = DateTime.Now.Date;
var valuesToFill = new Content(
new FieldContent("contract_type", profileName),
new FieldContent("contract_date", detail.DateAcepted.ToShortDateString()),
new FieldContent("customer_name", detail.Customer.ToString()),
new FieldContent("customer_dni", detail.Customer.Dni),
new FieldContent("customer_address", detail.Customer.ComercialInfo.Address),
new FieldContent("customer_city", detail.Customer.ComercialInfo.City.CityName),
new FieldContent("customer_single_profile_name", singleProfileName),
new FieldContent("customer_action", customerAction),
new FieldContent("contract_percent", contract.ContractCommission.ToString("N2")),
new FieldContent("additional_value", detail.AdditionalValue.ToString("N2")),
new FieldContent("fine_value", detail.FineValue.ToString("N2")),
new FieldContent("start_date", contract.StartDate.ToShortDateString()),
new FieldContent("end_date", contract.EndDate.ToShortDateString())
);
using (var outputDocument = new TemplateProcessor(fileName).SetRemoveContentControls(true)){
outputDocument.FillContent(valuesToFill);
outputDocument.SaveChanges();
}
var document = new Word2Pdf {
InputLocation = fileName,
OutputLocation = PdfFilePath
};
document.Word2PdfCOnversion();
File.Delete(fileName);
}
protected virtual void ContractDetail_RowInserting(PXCache sender, PXRowInsertingEventArgs e)
{
ContractDetail row = e.Row as ContractDetail;
if (row != null)
{
row.ContractID = Task.Current.ProjectID;
#region Check for Uniqueness
if (row.InventoryID.HasValue)
{
ContractDetail item = PXSelect <ContractDetail,
Where <ContractDetail.inventoryID, Equal <Required <InventoryItem.inventoryID> >,
And <ContractDetail.contractID, Equal <Current <PMTask.projectID> >,
And <ContractDetail.taskID, Equal <Current <PMTask.taskID> > > > > > .SelectWindowed(this, 0, 1, row.InventoryID);
if (item != null && item.ContractDetailID != row.ContractDetailID)
{
sender.RaiseExceptionHandling <ContractDetail.inventoryID>(row, row.InventoryID, new PXException(CT.Messages.ItemNotUnique));
e.Cancel = true;
}
}
#endregion
}
}
public void SaveContractType(ContractDetail _contract)
{
try
{
using (var ctx = new customerDbEntities())
{
ctx.ContractDetails.Add(_contract);
ctx.Entry(_contract).State = System.Data.Entity.EntityState.Modified;
ctx.SaveChanges();
}
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
public virtual void ContractItem_RowSelected(PXCache cache, PXRowSelectedEventArgs e)
{
ContractItem row = (ContractItem)e.Row;
if (row != null)
{
SetControlsState(cache, row);
ContractDetail detail = PXSelect <ContractDetail, Where <ContractDetail.contractItemID, Equal <Current <ContractItem.contractItemID> > > > .SelectWindowed(this, 0, 1);
ContractItems.Cache.AllowDelete = detail == null;
PXUIFieldAttribute.SetEnabled <ContractItem.curyID>(cache, row, detail == null);
PXDefaultAttribute.SetPersistingCheck <ContractItem.recurringItemID>(cache, row, row.RecurringType == RecurringOption.None ? PXPersistingCheck.Nothing : PXPersistingCheck.NullOrBlank);
PXUIFieldAttribute.SetRequired <ContractItem.recurringItemID>(cache, row.RecurringType != RecurringOption.None);
string message = null;
if (row.BaseItemID != null)
{
PXUIFieldAttribute.SetWarning <ContractItem.baseItemID>(cache, row, !IsValidBasePrice(this, row, ref message) ? Messages.ItemNotPrice : null);
}
if (row.RecurringItemID != null)
{
PXUIFieldAttribute.SetWarning <ContractItem.recurringItemID>(cache, row, !IsValidRecurringPrice(this, row, ref message) ? Messages.ItemNotPrice : null);
}
if (row.RenewalItemID != null)
{
PXUIFieldAttribute.SetWarning <ContractItem.renewalItemID>(cache, row, !IsValidRenewalPrice(this, row, ref message) ? Messages.ItemNotPrice : null);
}
}
}
public void DetailsTest()
{
TestDeploymentContext tdc = new TestDeploymentContext();
//adding one contract, as the contract requires a supplier id
ContractDetail x = new ContractDetail()
{
Contract_ID = 0, Supplier_ID = 0, ContractStartDate = new DateTime(10, 05, 2019),
ContractFinishDate = new DateTime(10, 05, 2020), Servicetype = Service.Waste, PriceDescription = "Hourly Price", Price = 22.00,
VatRate = 0.135, PriceUpdatedate = new DateTime(01 / 01 / 2019)
};
tdc.ContractDetail.Add(x);
Assert.IsNotNull(x);
tdc.Supplier.Add(new Supplier()
{
Supplier_ID = 0, SupplierNumber = "SN000", SupplierName = "Tipperary Water", SupplierAddress = "5 Cherry Orchard Industrial Estate, Ballyfermot, Dublin 10.", SupplierCounty = "Dublin", SupplierContact = "Lana kelly", SupplierEMail = "*****@*****.**"
});
var controller = new SuppliersController(tdc);
var result = controller.Details(0);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ViewResult));
Supplier y = new Supplier();
//(Supplier)((ViewResult)result).Model;
Assert.AreEqual(y.SupplierName, "Tipperary Water");
}
public void Notify(Contract contract, string pdfFilePath, MailTypeMessage typeMessage)
{
detail = contract.Details[0];
this.pdfFilePath = pdfFilePath;
this.typeMessage = typeMessage;
GenerateBody();
SendAnEmail();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
ContractDetail contractDetail = await db.ContractDetail.FindAsync(id);
db.ContractDetail.Remove(contractDetail);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public bool Update(ContractDetail obj)
{
var user = GetByTwoId(obj.ContractID, obj.ProductID);
user.Quantity = obj.Quantity;
user.Notes = obj.Notes;
return(db.SaveChanges() > 0);
}
public void ImportContractDetail(Stream stream, string sheetName)
{
NPOIHelper <string> nopi = new NPOIHelper <string>();
List <object> list = new List <object>();
list = nopi.GetExcel(stream, sheetName);
foreach (var obj in list)
{
Dictionary <string, string> dic = obj as Dictionary <string, string>;
var contractDetail = new ContractDetail();
contractDetail.Contract = db.Contracts.Find(int.Parse(Request.Params["ContractId"]));
if (dic.ContainsKey("设备材料名称") && !string.IsNullOrEmpty(dic["设备材料名称"]))
{
contractDetail.EquipmentMaterialName = dic["设备材料名称"];
}
if (dic.ContainsKey("品牌") && !string.IsNullOrEmpty(dic["品牌"]))
{
contractDetail.Brand = dic["品牌"];
}
if (dic.ContainsKey("规格") && !string.IsNullOrEmpty(dic["规格"]))
{
contractDetail.Specifications = dic["规格"];
}
if (dic.ContainsKey("单位") && !string.IsNullOrEmpty(dic["单位"]))
{
contractDetail.Unit = dic["单位"];
}
if (dic.ContainsKey("数量") && !string.IsNullOrEmpty(dic["数量"]))
{
contractDetail.Count = int.Parse(dic["数量"]);
}
if (dic.ContainsKey("单价") && !string.IsNullOrEmpty(dic["单价"]))
{
decimal unit = 0;
if (decimal.TryParse(dic["单价"], out unit))
{
contractDetail.UnitPrice = unit;
}
else
{
contractDetail.UnitPrice = 0;
}
}
contractDetail.PriceSum = contractDetail.UnitPrice * contractDetail.Count;
if (dic.ContainsKey("备注") && !string.IsNullOrEmpty(dic["备注"]))
{
contractDetail.Memo = dic["备注"];
}
db.ContractDetails.Add(contractDetail);
}
db.SaveChanges();
}
public static bool ValidItemForOnDemand(PXGraph graph, ContractDetail detail, out string itemCD)
{
ContractItem item = PXSelect <ContractItem, Where <ContractItem.contractItemID, Equal <Required <ContractDetail.contractItemID> > > > .Select(graph, detail.ContractItemID);
bool isInvalid = item?.RecurringItemID != null && item.DepositItemID == null && detail.Qty > 0m;
itemCD = isInvalid ? item.ContractItemCD : null;
return(!isInvalid);
}
//
// GET: /Site/Edit/5
public ActionResult Edit(int id)
{
SiteMonitoring e = repo.Get(id);
ContractDetailRepository cdrepo = new ContractDetailRepository();
ContractDetail cd = cdrepo.Get(e.ContractDetailID.ToInt());
e.Site = cd.Site;
return(View(e));
}
protected virtual void ContractDetail_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
ContractDetail row = e.Row as ContractDetail;
if (row != null && Task.Current != null)
{
PXUIFieldAttribute.SetEnabled <ContractDetail.included>(sender, row, Task.Current.IsActive != true);
}
}
protected virtual void ContractDetail_RowUpdating(PXCache sender, PXRowUpdatingEventArgs e)
{
ContractDetail row = e.NewRow as ContractDetail;
if (row != null)
{
ValidateUniqueness(sender, row, e);
}
}
public ActionResult Create(int?contractDetailID, IEnumerable <HttpPostedFileBase> files, string[] noteList)
{
repo.Create(UpdateModel, files, contractDetailID, noteList);
ContractDetailRepository contractDetailRepository = new ContractDetailRepository();
ContractDetail e = contractDetailRepository.Get(contractDetailID.Value);
return(RedirectToAction("Edit", "Contract", new { id = e.ContractID }));
}
protected virtual void ContractDetail_Qty_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
ContractDetail row = (ContractDetail)e.Row;
ContractItem item = PXSelect <ContractItem, Where <ContractItem.contractItemID, Equal <Required <ContractDetail.contractItemID> > > > .Select(this, row.ContractItemID);
if (item != null && (item.MaxQty < (decimal?)e.NewValue || item.MinQty > (decimal?)e.NewValue))
{
throw new PXSetPropertyException(Messages.QtyErrorWithParameters, PXDBQuantityAttribute.Round(item.MinQty ?? 0m), PXDBQuantityAttribute.Round(item.MaxQty ?? 0m));
}
}
public virtual void contractDetails(int reqId, ContractDetails contractDetails)
{
Console.WriteLine("ContractDetails begin. ReqId: " + reqId);
printContractMsg(contractDetails.Summary);
printContractDetailsMsg(contractDetails);
Console.WriteLine("ContractDetails end. ReqId: " + reqId);
ContractDetail contractDetail = new ContractDetail(reqId, contractDetails);
RaiseContractDetailsUpdatedEvent(new ContractDetailArgs(contractDetail));
}
public ContractDetail GetContractById(int id)
{
ContractDetail q = new ContractDetail();
using (var myContext = new customerDbEntities())
{
q = myContext.ContractDetails.Where(w => w.id == id).FirstOrDefault();
}
return(q);
}
protected static void UpdatePrices(ContractMaint graph, ContractDetail item)
{
Contract contract = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(graph, item.ContractID);
using (PXTransactionScope ts = new PXTransactionScope())
{
if (CTPRType.IsTemplate(contract.BaseType) != true)
{
ContractMaintExt contractMaintExt = CreateInstance <ContractMaintExt>();
contractMaintExt.Contracts.Current = contract;
if (contract.IsActive == true &&
contract.IsPendingUpdate != true &&
contract.Status != Contract.status.PendingActivation)
{
CTBillEngine engine = CreateInstance <CTBillEngine>();
engine.Upgrade(contract.ContractID);
engine.Clear();
contractMaintExt.Contracts.Current = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(engine, item.ContractID);
item = PXSelect <ContractDetail,
Where <ContractDetail.contractID, Equal <Required <ContractDetail.contractID> >,
And <ContractDetail.lineNbr, Equal <Required <ContractDetail.lineNbr> > > > > .Select(engine, item.ContractID, item.LineNbr);
}
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePrice>(item);
contractMaintExt.ContractDetails.Update(item);
contractMaintExt.Actions.PressSave();
}
else
{
TemplateMaint templateMaint = CreateInstance <TemplateMaint>();
templateMaint.Templates.Current = PXSelect <ContractTemplate, Where <ContractTemplate.contractID, Equal <Required <ContractTemplate.contractID> > > > .Select(graph, item.ContractID);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePrice>(item);
templateMaint.ContractDetails.Update(item);
templateMaint.Actions.PressSave();
}
ts.Complete();
}
}
public ActionResult Edit(ContractDetail model, int ContractId)
{
try {
model.Contract = db.Contracts.Find(ContractId);
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
} catch (Exception ex) {
return(Json(new { IsSuccess = false, Message = ex.Message }, "text/html", JsonRequestBehavior.AllowGet));
}
return(Json(new { IsSuccess = true, Message = "保存成功" }, "text/html", JsonRequestBehavior.AllowGet));
}
private void FileOperations(ContractDetail detail)
{
filePath = BasePath + @"\contratos";
templatePath = BasePath + @"\\templates";
VerifiPath();
fileName =
$@"{filePath}\contrato_{singleProfileName}_{detail.Customer}_{detail.DateAcepted.Year}-{detail.DateAcepted.Month}-{detail.DateAcepted.Day}.docx";
VerifyFile();
VerifyPdfFile();
CopyTemplate();
}
public ActionResult Create(ContractDetail model, int ContractId)
{
try {
// TODO: Add insert logic here
model.Contract = db.Contracts.Find(ContractId);
db.ContractDetails.Add(model);
db.SaveChanges();
} catch (Exception ex) {
return(Json(new { IsSuccess = false, Message = ex.Message }, "text/html", JsonRequestBehavior.AllowGet));
}
return(Json(new { IsSuccess = true, Message = "保存成功" }, "text/html", JsonRequestBehavior.AllowGet));
}
protected virtual void ContractDetail_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
ContractDetail row = e.Row as ContractDetail;
if (row != null && Task.Current != null)
{
PXUIFieldAttribute.SetEnabled <ContractDetail.included>(sender, row, Task.Current.IsActive != true);
PXUIFieldAttribute.SetEnabled <ContractDetail.accountID>(sender, e.Row, row.AccountSource != PMAccountSource.None);
PXUIFieldAttribute.SetEnabled <ContractDetail.subID>(sender, e.Row, row.AccountSource != PMAccountSource.None);
PXUIFieldAttribute.SetEnabled <ContractDetail.subMask>(sender, e.Row, row.AccountSource != PMAccountSource.None);
}
}
public async Task <ActionResult> Edit([Bind(Include = "Contract_ID,ContractStartDate,ContractFinishDate,ContractExtensionsAvailable,DurationContactExtension,Servicetype,PriceDescription,Price,VatRate,PriceUpdatedate,Supplier_ID")] ContractDetail contractDetails)
{
if (ModelState.IsValid)
{
db.Entry(contractDetails).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.Supplier_ID = new SelectList(db.Supplier, "Supplier_ID", "SupplierNumber", contractDetails.Supplier_ID);
return(View(contractDetails));
}
public ActionResult Create([Bind(Include = "Contract_ID,ContractStartDate,ContractFinishDate,ContractExtensionsAvailable,DurationContactExtension,Servicetype,PriceDescription,Price,VatRate,PriceUpdatedate,Supplier_ID")] ContractDetail contractDetail)
{
if (ModelState.IsValid)
{
db.ContractDetail.Add(contractDetail);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Supplier_ID = new SelectList(db.Supplier, "Supplier_ID", "SupplierNumber", contractDetail.Supplier_ID);
return(View(contractDetail));
}
protected virtual void ContractDetail_ContractItemID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
ContractDetail detail = (ContractDetail)e.Row;
ContractItem item = PXSelect <ContractItem, Where <ContractItem.contractItemID, Equal <Required <ContractDetail.contractItemID> > > > .Select(this, e.NewValue);
ContractTemplate template = PXSelect <ContractTemplate, Where <ContractTemplate.contractID, Equal <Required <ContractDetail.contractID> > > > .Select(this, detail.ContractID);
if (item != null && template != null && item.CuryID != template.CuryID)
{
e.NewValue = item.ContractItemCD;
throw new PXSetPropertyException(Messages.ItemHasAnotherCuryID, item.ContractItemCD, item.CuryID, template.CuryID, PXUIFieldAttribute.GetItemName(CurrentTemplate.Cache));
}
}
/// <summary>
/// add the
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool AddCustomer(OrderDetails model)
{
try
{
var objCustomerDetails = new ClientDetail();
objCustomerDetails.Name = model.CustomerName;
objCustomerDetails.Email = model.Email;
objCustomerDetails.BillingAddress = model.BillingAddress;
objCustomerDetails.ShippingAddress = model.ShippingAddress;
objCustomerDetails.Number = model.Number;
ObjEntity.ClientDetails.Add(objCustomerDetails);
ObjEntity.SaveChanges();
var objContractDetail = new ContractDetail();
objContractDetail.NetAmount = model.NetAmount;
objContractDetail.Quantity = model.Quantity;
objContractDetail.OrderAmount = model.OrderAmount;
objContractDetail.Tax = model.Tax;
objContractDetail.Discount = model.Discount;
objContractDetail.IsActive = true;
objContractDetail.TransactionDate = DateTime.Now;
objContractDetail.Customer_ID = objCustomerDetails.ID; ;
ObjEntity.ContractDetails.Add(objContractDetail);
int OrderNo= ObjEntity.SaveChanges();
var OrderItemDetails = new OrderItemDetail();
OrderItemDetails.Rate = model.Rate;
OrderItemDetails.Order_ID = objContractDetail.ID;
OrderItemDetails.Product_ID = 4;
OrderItemDetails.Quantity = model.Quantity.Value;
OrderItemDetails.Amount = model.Amount;
ObjEntity.OrderItemDetails.Add(OrderItemDetails);
ObjEntity.SaveChanges();
return true;
}
catch (Exception ex)
{
ExceptionHandling.SaveException(ex);
return false;
}
}
public Contract()
{
ContractDetail = new ContractDetail();
CurrencyContract = new CurrencyContract();
Calculator = new Calculator(this);
}
// 增加明细
private void tsbNew_Click(object sender, EventArgs e)
{
ContractDetail cd = new ContractDetail() { PayDate = DateTime.Now };
m_contract.DetailList.Add(cd);
gridControl1.DataSource = null;
gridControl1.DataSource = m_contract.DetailList;
}
public ContractDetail GetContractData(int contractNumber, int companyId)
{
try
{
DataSet contractData;
using (IO io = new IO(WebCommon.ConnectionString))
{
contractData = io.ExecuteDataSetQuery(IO.CreateCommandFromStoredProc("DIGITALLIBRARY_GETCONTRACTDETAIL",
Param.CreateParam("CONTRACTNUMBER", SqlDbType.Int, contractNumber),
Param.CreateParam("COMPANYID", SqlDbType.Int, companyId)));
}
if (contractData == null || contractData.Tables[0].Rows.Count <= 0)
{
return new ContractDetail();
}
ContractDetail contractDetail = new ContractDetail();
contractDetail.ContractNumber = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "CONTRACT_NUMBER", ""));
contractDetail.Agency = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "AGENCY", ""));
contractDetail.Advertiser = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "ADVERTISER", ""));
contractDetail.AE1 = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "AE_1_NAME", ""));
contractDetail.AE2 = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "AE_2_NAME", ""));
contractDetail.AE3 = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "AE_3_NAME", ""));
contractDetail.Program = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "PROGRAM", ""));
contractDetail.Company = Convert.ToString(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "COMPANY", ""));
contractDetail.CompanyId = Convert.ToInt32(IO.GetDataRowValue(contractData.Tables[0].Rows[0], "COMPANY_ID", 1));
contractDetail.ContractDetailLines = new List<ContractDetailLine>();
foreach (DataRow row in contractData.Tables[0].Rows)
{
contractDetail.ContractDetailLines.Add(new ContractDetailLine
{
Market = Convert.ToString(IO.GetDataRowValue(row, "MARKET", "")),
SalesMarket = Convert.ToString(IO.GetDataRowValue(row, "SALES_MARKET", "")),
LineMessage = Convert.ToString(IO.GetDataRowValue(row, "LINE_MESSAGE", "")),
ProfitCenter = Convert.ToString(IO.GetDataRowValue(row, "PROFIT_CENTER", "")),
MediaType = Convert.ToString(IO.GetDataRowValue(row, "MEDIA_TYPE", "")),
MediaForm = Convert.ToString(IO.GetDataRowValue(row, "MEDIA_FORM", "")),
StartDateDisplay = Convert.ToString(IO.GetDataRowValue(row, "START_DATE", "")),
EndDateDisplay = Convert.ToString(IO.GetDataRowValue(row, "END_DATE", "")),
Quantity = Convert.ToInt32(IO.GetDataRowValue(row, "QUANTITY", 0)),
Reason = (Convert.ToString(IO.GetDataRowValue(row, "REASON", "")) == "B" ? "Bonus" : (Convert.ToString(IO.GetDataRowValue(row, "REASON", "")) == "A" ? "Added" : Convert.ToString(IO.GetDataRowValue(row, "REASON", "")))),
LineItemNumber = Convert.ToInt32(IO.GetDataRowValue(row, "LINE_ITEM_NUMBER", 0))
});
}
return contractDetail;
}
catch (Exception ex)
{
WebCommon.LogExceptionInfo(ex);
return new ContractDetail();
}
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// a Contract Template and several Contracts are created, demonstrating how to
/// create and work with the Contract entity.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetWorkingWithContracts1>
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
#region Create Contract Template
// First, attempt to retrieve the Contract Template. Otherwise,
// create the template.
QueryExpression templateQuery = new QueryExpression()
{
EntityName = ContractTemplate.EntityLogicalName,
ColumnSet = new ColumnSet("contracttemplateid"),
Criteria =
{
Conditions =
{
new ConditionExpression("abbreviation", ConditionOperator.Equal, "SCT")
}
}
};
EntityCollection ec = _serviceProxy.RetrieveMultiple(templateQuery);
if (ec.Entities.Count > 0)
{
_contractTemplateId = ec.Entities[0].Id;
Console.Write("Template retrieved, ");
}
else
{
ContractTemplate contractTemplate = new ContractTemplate()
{
Name = "Sample Contract Template",
BillingFrequencyCode = new OptionSetValue((int)ContractTemplateBillingFrequencyCode.Monthly),
Abbreviation = "SCT",
AllotmentTypeCode = new OptionSetValue((int)ContractTemplateAllotmentTypeCode.NumberofCases),
EffectivityCalendar =
"--------+++++++++---------------+++++++++---------------+++++++++---------------+++++++++---------------+++++++++-------------------------------------------------------"
};
_contractTemplateId = _serviceProxy.Create(contractTemplate);
Console.Write("Template created, ");
}
#endregion
#region Create Contract
// Create a Contract from the Contract Template.
Contract contract = new Contract()
{
Title = "Sample Contract",
ContractTemplateId = new EntityReference
{
Id = _contractTemplateId,
LogicalName = ContractTemplate.EntityLogicalName
},
CustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
BillingCustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
ActiveOn = new DateTime(2015, 1, 1),
ExpiresOn = new DateTime(2020, 1, 1),
BillingStartOn = new DateTime(2015, 1, 1),
BillingEndOn = new DateTime(2020, 1, 1)
};
_contractId = _serviceProxy.Create(contract);
Console.Write("parent contract created, ");
// Create a contract line item.
ContractDetail contractLineItem = new ContractDetail()
{
Title = "Sample Contract Line Item",
ContractId = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
CustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
ActiveOn = new DateTime(2015, 1, 1),
ExpiresOn = new DateTime(2020, 1, 1),
Price = new Money(20.0M),
TotalAllotments = 20
};
_serviceProxy.Create(contractLineItem);
Console.Write("contract line attached, ");
#endregion
#region Clone contract twice
//<snippetCloneContract>
// Create the first clone of the contract.
CloneContractRequest cloneRequest = new CloneContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = false
};
CloneContractResponse cloneResponse =
(CloneContractResponse)_serviceProxy.Execute(cloneRequest);
_firstCloneId = ((Contract)cloneResponse.Entity).ContractId.Value;
//</snippetCloneContract>
Console.Write("first clone created, ");
// Create the second clone of the contract.
cloneRequest = new CloneContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = true
};
cloneResponse =
(CloneContractResponse)_serviceProxy.Execute(cloneRequest);
_secondCloneId = ((Contract)cloneResponse.Entity).ContractId.Value;
Console.Write("second clone created. \n");
// Retrieve all Contracts.
QueryExpression contractQuery = new QueryExpression()
{
EntityName = Contract.EntityLogicalName,
ColumnSet = new ColumnSet("contractid"),
Criteria =
{
Conditions =
{
new ConditionExpression("customerid", ConditionOperator.Equal, _accountId)
}
}
};
EntityCollection contracts = _serviceProxy.RetrieveMultiple(contractQuery);
// Display the retrieved Contract Ids.
for (int i = 0; i < contracts.Entities.Count; i++)
{
Console.WriteLine("Retrieved contract with Id: {0}",
((Contract)contracts.Entities[i]).ContractId);
}
#endregion
#region Deactivate a cloned contract
// In order to deactivate a contract (put it on hold), it is first
// necessary to invoice the contract.
SetStateRequest setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _firstCloneId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Invoiced),
Status = new OptionSetValue(2)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("Contract invoiced, ");
// Now that the contract has been invoiced, it is possible to put
// the contract on hold.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _firstCloneId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.OnHold),
Status = new OptionSetValue(4)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("and put on hold.\n");
#endregion
#region Renew an invoiced contract
// In order to renew a contract, it must be invoiced first, and
// then canceled.
//<snippetSetStateForContract>
// Invoice the contract.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Invoiced),
Status = new OptionSetValue(3)
};
_serviceProxy.Execute(setStateRequest);
//</snippetSetStateForContract>
Console.Write("Contract invoiced, ");
//<snippetCancelContract>
// Cancel the contract.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Canceled),
Status = new OptionSetValue(5)
};
_serviceProxy.Execute(setStateRequest);
//</snippetCancelContract>
Console.Write("canceled, ");
//<snippetRenewContract>
// Renew the canceled contract.
RenewContractRequest renewRequest = new RenewContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = true,
Status = 1
};
RenewContractResponse renewResponse =
(RenewContractResponse)_serviceProxy.Execute(renewRequest);
// Retrieve Id of renewed contract.
_renewedId = ((Contract)renewResponse.Entity).ContractId.Value;
//</snippetRenewContract>
// Display the Id of the renewed contract.
Console.WriteLine("and renewed.");
#endregion
DeleteRequiredRecords(promptforDelete);
}
//</snippetWorkingWithContracts1>
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
