/// <summary> /// Loads the documents' templates into cache. /// </summary> private void LoadTemplates() { XDocument xml = this.ExecuteStoredProcedure(null, StoredProcedure.configuration_p_getConfiguration, true, XDocument.Parse(@"<root><entry>templates.CommercialDocument.*</entry> <entry>templates.WarehouseDocument.*</entry> <entry>templates.FinancialDocument.*</entry> <entry>templates.Item.*</entry> <entry>templates.Contractor.*</entry> <entry>templates.ServiceDocument.*</entry> <entry>templates.ComplaintDocument.*</entry> <entry>templates.InventoryDocument.*</entry> <entry>templates.OfferDocument.*</entry> </root>")); this.Templates = new Dictionary <BusinessObjectType, Dictionary <string, XElement> >(); foreach (XElement entry in xml.Root.Element("configuration").Elements().OrderBy(c => Convert.ToInt32(c.Element("xmlValue").Element("root").Element("order").Value, CultureInfo.InvariantCulture))) { string[] splitted = entry.Element("key").Value.Split('.'); BusinessObjectType type = (BusinessObjectType)Enum.Parse(typeof(BusinessObjectType), splitted[1], true); string templateName = splitted[2]; if (!this.Templates.ContainsKey(type)) { this.Templates.Add(type, new Dictionary <string, XElement>()); } this.Templates[type].Add(templateName, (XElement)entry.Element("xmlValue").FirstNode); } }
/// <summary> /// Deletes business object. /// </summary> /// <param name="type">Type of <see cref="BusinessObject"/> to delete.</param> /// <param name="id">Id of the object to delete.</param> public override void DeleteBusinessObject(BusinessObjectType type, Guid id) { if (type == BusinessObjectType.FileDescriptor) { this.ExecuteStoredProcedure(StoredProcedure.repository_p_deleteFileDescriptor, false, "@id", id); } }
/// <summary> /// Creates a <see cref="BusinessObject"/> of a selected type. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to create.</param> /// <param name="requestXml">Client requestXml containing initial parameters for the object.</param> /// <returns>A new <see cref="IBusinessObject"/>.</returns> public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { IBusinessObject bo = null; switch (type) { case BusinessObjectType.Contractor: bo = this.CreateNewContractor(); break; case BusinessObjectType.Bank: bo = new Bank(null); break; case BusinessObjectType.Employee: bo = new Employee(null); break; case BusinessObjectType.ApplicationUser: bo = new ApplicationUser(null); break; default: throw new InvalidOperationException("ContractorMapper can only create contractors/banks/employees."); } bo.GenerateId(); return(bo); }
public override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { StoredProcedure?sp = null; string procedureParamName = null; string tableName = null; if (type == BusinessObjectType.ShiftTransaction) { sp = StoredProcedure.warehouse_p_getShiftTransactionData; procedureParamName = "@shiftTransactionId"; tableName = "shiftTransaction"; } else if (type == BusinessObjectType.Container) { sp = StoredProcedure.warehouse_p_getContainer; procedureParamName = "@containerId"; tableName = "container"; } else { throw new InvalidOperationException("This type of object is not supported by WarehouseMapper."); } XDocument xdoc = this.ExecuteStoredProcedure(sp.Value, true, procedureParamName, id); if (xdoc.Root.Element(tableName).Elements().Count() == 0) { throw new ClientException(ClientExceptionId.ObjectNotFound); } xdoc = this.ConvertDBToBoXmlFormat(xdoc, id); return(this.ConvertToBusinessObject(xdoc.Root.Element(tableName), null)); }
/// <summary> /// Initializes a new instance of the <see cref="Item"/> class with a specified xml root element and default settings. /// </summary> /// <param name="parent">Parent <see cref="BusinessObject"/>.</param> /// <param name="boType">Type of <see cref="BusinessObject"/>.</param> public Item(BusinessObject parent, BusinessObjectType boType) : base(parent, boType) { this.Attributes = new ItemAttrValues(this); this.Relations = new ItemRelations(this); this.UnitRelations = new ItemUnitRelations(this); this.GroupMemberships = new ItemGroupMemberships(this); }
/// <summary> /// Initializes a new instance of the <see cref="BusinessObject"/> class with a specified xml root element. /// </summary> /// <param name="parent">Parent <see cref="BusinessObject"/>.</param> /// <param name="boType">Type of <see cref="BusinessObject"/>.</param> protected BusinessObject(BusinessObject parent, BusinessObjectType boType) { this.Parent = parent; this.BOType = boType; if (this.Id == null) { this.GenerateId(); } }
/// <summary> /// Performs initial validation. /// </summary> /// <param name="requestXml">Client's request containing <see cref="BusinessObject"/>'s xml and its options.</param> protected override void PerformInitialValidation(XDocument requestXml) { string boType = ((XElement)requestXml.Root.FirstNode).Attribute("type").Value; BusinessObjectType type = (BusinessObjectType)Enum.Parse(typeof(BusinessObjectType), boType); if (!this.MapperTyped.SupportedBusinessObjectsTypes.Contains(type)) { throw new ClientException(ClientExceptionId.UnknownBusinessObjectType, null, "objType:" + boType); } }
public XElement GetDocumentOperations(BusinessObjectType type, Guid id) { Document document = null; using (Coordinator c = Coordinator.GetCoordinatorForSpecifiedType(type)) { document = (Document)c.LoadBusinessObject(type, id); } return(this.GetDocumentOperations(document)); }
/// <summary> /// Creates a <see cref="BusinessObject"/> of a selected type. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to create.</param> /// <param name="requestXml">Client requestXml containing initial parameters for the object.</param> /// <returns>A new <see cref="IBusinessObject"/>.</returns> public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { if (type != BusinessObjectType.Configuration) { throw new InvalidOperationException("ConfigurationMapper can only create configuration."); } Configuration conf = new Configuration(); return(conf); }
/// <summary> /// Initializes a new instance of the <see cref="Document"/> class with a specified xml root element and default settings. /// </summary> /// <param name="parent">Parent <see cref="BusinessObject"/>.</param> /// <param name="boType">Type of <see cref="Document"/>.</param> public Document(BusinessObjectType boType) : base(boType) { this.DocumentOptions = new List <IDocumentOption>(); this.Attributes = new DocumentAttrValues(this); this.Relations = new DocumentRelations(this); //defaults this.SystemCurrencyId = ConfigurationMapper.Instance.SystemCurrencyId; this.DocumentCurrencyId = ConfigurationMapper.Instance.SystemCurrencyId; }
/// <summary> /// Initializes a new instance of the <see cref="Contractor"/> class with a specified xml root element and default settings. /// </summary> /// <param name="parent">Parent <see cref="BusinessObject"/>.</param> /// <param name="boType">Type of <see cref="Contractor"/>.</param> public Contractor(BusinessObject parent, BusinessObjectType boType) : base(parent, boType) { this.Accounts = new ContractorAccounts(this); this.Addresses = new ContractorAddresses(this); this.Attributes = new ContractorAttrValues(this); this.Relations = new ContractorRelations(this); this.GroupMemberships = new ContractorGroupMemberships(this); this.NipPrefixCountryId = DictionaryMapper.Instance.GetCountry("PL").Id.Value; }
/// <summary> /// Loads the <see cref="BusinessObject"/> with a specified Id. /// </summary> /// <param name="type">Type of <see cref="BusinessObject"/> to load.</param> /// <param name="id"><see cref="IBusinessObject"/>'s id indicating which <see cref="BusinessObject"/> to load.</param> /// <returns> /// Loaded <see cref="IBusinessObject"/> object. /// </returns> public override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { XDocument xdoc = this.ExecuteStoredProcedure(StoredProcedure.contractor_p_getContractorData, true, "@contractorId", id); if (xdoc.Root.Element("contractor").Elements().Count() == 0) { throw new ClientException(ClientExceptionId.ContractorNotFound); } xdoc = this.ConvertDBToBoXmlFormat(xdoc, id); return(this.ConvertToBusinessObject(xdoc.Root.Element("contractor"), null)); }
/// <summary> /// Loads the <see cref="BusinessObject"/> with a specified Id. /// </summary> /// <param name="type">Type of <see cref="BusinessObject"/> to load.</param> /// <param name="id"><see cref="IBusinessObject"/>'s id indicating which <see cref="BusinessObject"/> to load.</param> /// <returns> /// Loaded <see cref="IBusinessObject"/> object. /// </returns> public override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { XDocument xdoc = this.ExecuteStoredProcedure(StoredProcedure.repository_p_getFileDescriptor, true, "@id", id); if (xdoc.Root.Element("fileDescriptor").Elements().Count() == 0) { throw new ClientException(ClientExceptionId.ObjectNotFound); } xdoc = this.ConvertDBToBoXmlFormat(xdoc, id); return(this.ConvertToBusinessObject(xdoc.Root.Element("fileDescriptor"), null)); }
public override void DeleteBusinessObject(BusinessObjectType type, Guid id) { try { this.ExecuteStoredProcedure(StoredProcedure.contractor_p_deleteContractor, false, "@contractorId", id); } catch (SqlException ex) { RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:120"); if (ex.Number == 50000) { throw new ClientException(ClientExceptionId.ContractorRemovalError); } } }
/// <summary> /// Creates a <see cref="BusinessObject"/> of a selected type. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to create.</param> /// <param name="requestXml">Client requestXml containing initial parameters for the object.</param> /// <returns>A new <see cref="IBusinessObject"/>.</returns> public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { IBusinessObject bo = null; if (type == BusinessObjectType.Item) { bo = new Item(null); } else { throw new InvalidOperationException("ItemMapper can only create items."); } bo.GenerateId(); return(bo); }
public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { IBusinessObject bo = null; switch (type) { case BusinessObjectType.ServicedObject: bo = new ServicedObject(); break; default: throw new InvalidOperationException("ServiceMapper cannot create such object."); } bo.GenerateId(); return(bo); }
/// <summary> /// Creates a <see cref="BusinessObject"/> of a selected type. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to create.</param> /// <param name="requestXml">Client requestXml containing initial parameters for the object.</param> /// <returns>A new <see cref="IBusinessObject"/>.</returns> public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { IBusinessObject bo = null; switch (type) { case BusinessObjectType.FileDescriptor: bo = this.CreateNewFileDescriptor(); break; default: throw new InvalidOperationException("RepositoryMapper can only create fileDescriptors."); } bo.GenerateId(); return(bo); }
/// <summary> /// Loads the <see cref="BusinessObject"/> with a specified Id. It appends modification user name. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to load.</param> /// <param name="id">The id of the <see cref="IBusinessObject"/> to load.</param> /// <returns>Loaded <see cref="BusinessObject"/></returns> internal override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { Contractor result = this.MapperTyped.LoadBusinessObject(id); if (result.ModificationUserId.HasValue) { Contractor modificationUser = this.MapperTyped.LoadBusinessObject(result.ModificationUserId.Value); result.ModificationUser = modificationUser.FullName; } if (result.CreationUserId.HasValue) { Contractor creationUser = this.MapperTyped.LoadBusinessObject(result.CreationUserId.Value); result.CreationUser = creationUser.FullName; } return(result); }
/// <summary> /// Deletes business object. /// </summary> /// <param name="requestXml">Client's request containing <see cref="BusinessObject"/>'s id to delete.</param> public override void DeleteBusinessObject(XDocument requestXml) { BusinessObjectType type = BusinessObjectType.Other; try { type = (BusinessObjectType)Enum.Parse(typeof(BusinessObjectType), requestXml.Root.Element("type").Value); } catch (ArgumentException) { RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:93"); throw new ClientException(ClientExceptionId.UnknownBusinessObjectType, null, "objType:" + requestXml.Root.Element("type").Value); } Guid id = new Guid(requestXml.Root.Element("id").Value); this.Mapper.DeleteBusinessObject(type, id); }
/// <summary> /// Loads the <see cref="BusinessObject"/> with a specified Id. It appends modification user name. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to load.</param> /// <param name="id">The id of the <see cref="IBusinessObject"/> to load.</param> /// <returns>Loaded <see cref="BusinessObject"/></returns> internal override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { Item result = (Item)this.MapperTyped.LoadBusinessObject(BusinessObjectType.Item, id); ContractorMapper contractorMapper = new ContractorMapper(); if (result.ModificationUserId.HasValue) { Contractor modificationUser = contractorMapper.LoadBusinessObject(result.ModificationUserId.Value); result.ModificationUser = modificationUser.FullName; } if (result.CreationUserId.HasValue) { Contractor creationUser = contractorMapper.LoadBusinessObject(result.CreationUserId.Value); result.CreationUser = creationUser.FullName; } return(result); }
public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { IBusinessObject bo = null; switch (type) { case BusinessObjectType.ShiftTransaction: bo = new ShiftTransaction(null); break; case BusinessObjectType.Container: bo = new Container(null); break; default: throw new InvalidOperationException("WarehouseMapper cannot create this type of objects."); } bo.GenerateId(); return(bo); }
public CommercialDocumentBase(BusinessObjectType boType) : base(boType) { this.Lines = new CommercialDocumentLines(this); this.VatTableEntries = new CommercialDocumentVatTableEntries(this); DateTime currentDateTime = SessionManager.VolatileElements.CurrentDateTime; //document defaults this.EventDate = currentDateTime; this.IssuePlaceId = new Guid(ConfigurationMapper.Instance.GetSingleConfigurationEntry("document.defaults.issuePlaceId").Value.Value); this.ExchangeDate = currentDateTime.PreviousWorkDay(); this.ExchangeScale = 1; this.ExchangeRate = 1; Contractor issuingPerson = (Contractor)DependencyContainerManager.Container.Get <ContractorMapper>().LoadBusinessObject(BusinessObjectType.Contractor, SessionManager.User.UserId); this.IssuingPerson = issuingPerson; Contractor issuer = (Contractor)DependencyContainerManager.Container.Get <ContractorMapper>().LoadBusinessObject(BusinessObjectType.Contractor, new Guid(ConfigurationMapper.Instance.GetConfiguration(SessionManager.User, "document.defaults.issuerId").First().Value.Value)); this.Issuer = issuer; //znajdywanie adresu do faktury Guid billingId = DictionaryMapper.Instance.GetContractorField(ContractorFieldName.Address_Billing).Id.Value; Guid defaultId = DictionaryMapper.Instance.GetContractorField(ContractorFieldName.Address_Default).Id.Value; ContractorAddress issuerAddress = issuer.Addresses.Children.Where(a => a.ContractorFieldId == billingId).FirstOrDefault(); if (issuerAddress == null) { issuerAddress = issuer.Addresses.Children.Where(a => a.ContractorFieldId == defaultId).FirstOrDefault(); } if (issuerAddress == null) { throw new ClientException(ClientExceptionId.MissingDefaultOrBillingAddress, null, "name:" + issuer.FullName); } this.IssuerAddressId = issuerAddress.Id.Value; }
/// <summary> /// Initializes a new instance of the <see cref="Document"/> class with a specified xml root element and default settings. /// </summary> /// <param name="parent">Parent <see cref="BusinessObject"/>.</param> /// <param name="boType">Type of <see cref="Document"/>.</param> public SimpleDocument(BusinessObjectType boType) : base(null, boType) { this.RelatedObjects = new List <IBusinessObject>(); //defaults this.Number = new DocumentNumber(this); var defaultNumberSettingIdConf = ConfigurationMapper.Instance.GetSingleConfigurationEntry("document.defaults.numberSettingId"); if (defaultNumberSettingIdConf == null) { throw new InvalidOperationException("Missing configuration setting: 'document.defaults.numberSettingId'"); } this.Number.NumberSettingId = new Guid(defaultNumberSettingIdConf.Value.Value); this.IssueDate = SessionManager.VolatileElements.CurrentDateTime; User user = SessionManager.User; this.BranchId = user.BranchId; this.CompanyId = user.CompanyId; }
/// <summary> /// Gets the random keywords collection for the specified business object type. /// </summary> /// <param name="type">The type of business object to get the keywords for.</param> /// <param name="amount">The amount of random keywords to get.</param> /// <returns>List of random keywords.</returns> public XDocument GetRandomBusinessObjectKeywords(BusinessObjectType type, int amount) { XDocument xml = XDocument.Parse("<root amount=\"" + amount.ToString(CultureInfo.InvariantCulture) + "\" />"); StoredProcedure sp; if (type == BusinessObjectType.Item) { sp = StoredProcedure.item_p_getRandomKeywords; } else if (type == BusinessObjectType.Contractor) { sp = StoredProcedure.contractor_p_getRandomKeywords; } else { throw new NotSupportedException("Object type not supported"); } xml = this.ExecuteStoredProcedure(sp, true, xml); return(xml); }
public async Task <Unit> Handle(UpdateInterfaceStatusCommand request, CancellationToken cancellationToken) { foreach (var item in request.AccountingInterfaceError) { bool isResendRequest = true; int tAorJLTypeId = 0; if (item.TransactionDocumentTypeId == DocumentType.ManualTemporaryAdjustment) { tAorJLTypeId = await _accountingInterfaceRepository.GetTATypeIdAsync(item.TransactionDocumentId, item.TransactionDocumentTypeId, request.Company); } BusinessObjectType businessObjectType = await GetBusinessObjectType(item.TransactionDocumentTypeId, tAorJLTypeId); var eventDto = new EventDto(item.AccountingId, item.DocumentReference, (int)businessObjectType, request.Company); var eventStatus = await _interfaceEventLogService.FindEventAsync(eventDto); if (eventStatus != null) { var processInterfaceData = new ProcessInterfaceDataChangeLogsRequest { DocumentTypeId = item.TransactionDocumentTypeId, CompanyId = request.Company, BusinessApplicationType = BusinessApplicationType.AX, TransactionDocumentId = item.TransactionDocumentId, DocumentId = item.AccountingId, }; if (Enum.TryParse(request.AccountingInterfaceStatus, out InterfaceStatus status)) { AuthorizationResult res = await this.CheckPrivileges(status); if (res.Succeeded) { switch (status) { case InterfaceStatus.NotInterfaced: _unitOfWork.BeginTransaction(); try { await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.NotInterfaced, "Rejected from Error Management Screen", processInterfaceData.ESBMessage, ResultCode.Cancel.ToString(), null, processInterfaceData.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.NotInterfaced, "Rejected from Error Management Screen"); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } break; case InterfaceStatus.TransmitError: case InterfaceStatus.InterfaceReady: // Made changes to process the document directly instead of queueing into Process.Queue // Processing it instead of queueing since we received bug which states document status after resend is not updated immediately var companyDate = await _systemDateTimeService.GetCompanyDate(processInterfaceData.CompanyId); if (processInterfaceData.DocumentTypeId == DocumentType.ManualTemporaryAdjustment) { tAorJLTypeId = await _accountingInterfaceRepository.GetTATypeIdAsync(processInterfaceData.TransactionDocumentId, processInterfaceData.DocumentTypeId, processInterfaceData.CompanyId); } if (processInterfaceData.DocumentTypeId == DocumentType.RegularJournal) { tAorJLTypeId = await _accountingInterfaceRepository.GetJLTypeIdAsync(processInterfaceData.TransactionDocumentId, processInterfaceData.DocumentTypeId, processInterfaceData.CompanyId); } _unitOfWork.BeginTransaction(); try { await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.InterfaceReady, "Resend from Error Management Screen", processInterfaceData.ESBMessage, null, null, processInterfaceData.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.InterfaceReady, "Resend from Error Management Screen"); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } _logger.LogInformation("Accounting Document with DocumentId {Atlas_DocumentId} having status {Atlas_Status} is sent to Accounting System at {Atlas_DateTime}", processInterfaceData.DocumentId, InterfaceStatus.ReadyToTransmit, companyDate); var accountingInterfaceXMLMessage = await _accountingInterfaceRepository.GetESBMessageAsync(processInterfaceData.DocumentId, processInterfaceData.CompanyId); // send the business object to Interface await SendBusinessObjectToInterface(processInterfaceData, accountingInterfaceXMLMessage, tAorJLTypeId, eventStatus.EventId, isResendRequest); break; } } else { throw new AtlasSecurityException("One or more privileges are required to perform this action."); } } _logger.LogInformation("Accounting Error with id {Atlas_DocumentReference} updated.", item.DocumentReference); } } return(Unit.Value); }
/// <summary> /// Gets the random keywords collection for the specified business object type. /// </summary> /// <param name="type">The type of business object to get the keywords for.</param> /// <param name="amount">The amount of random keywords to get.</param> /// <returns>List of random item keywords.</returns> public XDocument GetRandomBusinessObjectKeywords(BusinessObjectType type, int amount) { return(((ListMapper)this.Mapper).GetRandomBusinessObjectKeywords(type, amount)); }
/// <summary> /// Initializes a new instance of the <see cref="MassiveBusinessObjectCollection<T>"/> class. /// </summary> public MassiveBusinessObjectCollection() : base(null, typeof(T).Name.Decapitalize()) { this.type = (BusinessObjectType)Enum.Parse(typeof(BusinessObjectType), typeof(T).Name, true); }
/// <summary> /// Gets the templates of all document types. /// </summary> /// <returns>Templates list.</returns> public XDocument GetTemplates() { XDocument xml = XDocument.Parse("<root><warehouseDocument/><salesDocument/><purchaseDocument/><orderDocument/><financialDocument/><salesOrderDocument/><item/><contractor/><serviceDocument/><complaintDocument/><inventoryDocument/><technologyDocument/><productionOrderDocument/></root>"); BusinessObjectType[] types = new BusinessObjectType[] { BusinessObjectType.WarehouseDocument, BusinessObjectType.CommercialDocument, BusinessObjectType.FinancialDocument, BusinessObjectType.Item, BusinessObjectType.Contractor, BusinessObjectType.ServiceDocument, BusinessObjectType.ComplaintDocument, BusinessObjectType.InventoryDocument }; DictionaryMapper.Instance.CheckForChanges(); foreach (BusinessObjectType type in types) { if (!ConfigurationMapper.Instance.Templates.ContainsKey(type)) { continue; } foreach (string templateName in ConfigurationMapper.Instance.Templates[type].Keys) { XElement fullTemplate = ConfigurationMapper.Instance.Templates[type][templateName]; if (fullTemplate.Element("visible") != null && fullTemplate.Element("visible").Value.ToUpperInvariant() == "FALSE") { continue; } XElement labelsElement = fullTemplate.Element("labels"); string Lang = fullTemplate.Element("labels").Elements().Aggregate("", (b, node) => b += ";" + node.Value.ToString()); XElement template = new XElement("template", new XAttribute("id", templateName), new XAttribute("label", BusinessObjectHelper.GetXmlLabelInUserLanguage(fullTemplate.Element("labels")).Value), new XAttribute("labelEn", Lang), //preferredLang.FirstOrDefault().ToString() new XAttribute("icon", fullTemplate.Element("icon").Value)); if (fullTemplate.Element("isDefault") != null && fullTemplate.Element("isDefault").Value.ToUpperInvariant() == "TRUE") { template.Add(new XAttribute("isDefault", "true")); } DocumentCategory?dc = null; XElement documentTypeIdElement = ((XElement)fullTemplate.FirstNode).Element("documentTypeId"); if (documentTypeIdElement != null) { template.Add(new XAttribute("documentTypeId", documentTypeIdElement.Value)); Guid documentTypeId = new Guid(documentTypeIdElement.Value); DocumentType dt = DictionaryMapper.Instance.GetDocumentType(documentTypeId); if (dt == null) { throw new ArgumentException(String.Format("Invalid documentTypeId: {0} in template: {1}", documentTypeId.ToUpperString(), templateName)); } dc = dt.DocumentCategory; } if (dc == DocumentCategory.Sales) { xml.Root.Element("salesDocument").Add(template); } else if (dc == DocumentCategory.Purchase) { xml.Root.Element("purchaseDocument").Add(template); } else if (dc == DocumentCategory.Warehouse) { xml.Root.Element("warehouseDocument").Add(template); } else if (dc == DocumentCategory.Order || dc == DocumentCategory.Reservation) { xml.Root.Element("orderDocument").Add(template); } else if (dc == DocumentCategory.Financial) { xml.Root.Element("financialDocument").Add(template); } else if (dc == DocumentCategory.Service) { xml.Root.Element("serviceDocument").Add(template); } else if (dc == DocumentCategory.Complaint) { xml.Root.Element("complaintDocument").Add(template); } else if (dc == DocumentCategory.Inventory) { xml.Root.Element("inventoryDocument").Add(template); } else if (dc == DocumentCategory.SalesOrder) { xml.Root.Element("salesOrderDocument").Add(template); } else if (dc == DocumentCategory.Technology) { xml.Root.Element("technologyDocument").Add(template); } else if (dc == DocumentCategory.ProductionOrder) { xml.Root.Element("productionOrderDocument").Add(template); } else if (dc == null) { xml.Root.Element(type.ToString().Decapitalize()).Add(template); } } } return(xml); }
/// <summary> /// Loads the <see cref="BusinessObject"/> with a specified Id. /// </summary> /// <param name="type">Type of <see cref="BusinessObject"/> to load.</param> /// <param name="id"><see cref="IBusinessObject"/>'s id indicating which <see cref="BusinessObject"/> to load.</param> /// <returns> /// Loaded <see cref="IBusinessObject"/> object. /// </returns> public override IBusinessObject LoadBusinessObject(BusinessObjectType type, Guid id) { throw new NotImplementedException(); }
/// <summary> /// Creates a <see cref="BusinessObject"/> of a selected type. /// </summary> /// <param name="type">The type of <see cref="IBusinessObject"/> to create.</param> /// <param name="requestXml">Client requestXml containing initial parameters for the object.</param> /// <returns>A new <see cref="IBusinessObject"/>.</returns> public override IBusinessObject CreateNewBusinessObject(BusinessObjectType type, XDocument requestXml) { throw new NotImplementedException(); }