public EntryMappingMetaClass(MetaDataContext context, int metaClassId, int CatalogId)
: base(context)
{
MetaClass mc = MetaClass.Load(context, metaClassId);
InnerMetaClassName = mc.Name;
_metaClassId = metaClassId;
_CatalogId = CatalogId;
}
protected void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
private void CreateMetaClass(MetaDataContext mdContext, string parentName, string metaDataNamespace, string name, string tableName, string description)
{
MetaClass parentClass = MetaClass.Load(mdContext, parentName);
if (MetaClass.Load(mdContext, name) == null)
{
MetaClass.Create(mdContext, metaDataNamespace, name, name, tableName, parentClass, false, description);
}
}
public static DataSet ExecuteDataset(MetaDataContext context, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (context == null)
throw new ArgumentNullException("context");
if (context.Transaction != null)
return ExecuteDataset(context.Transaction, commandType, commandText, commandParameters);
else
return ExecuteDataset(context.ConnectionString, commandType, commandText, commandParameters);
}
public void Initialize(InitializationEngine context)
{
MetaDataContext mdContext = CatalogContext.MetaDataContext;
// Purchase order meta fields
JoinField(mdContext, GetOrCreateCardField(mdContext, Common.Constants.KlarnaOrderIdField), Common.Constants.PurchaseOrderClass);
// Other payment meta fields
JoinField(mdContext, GetOrCreateCardField(mdContext, Common.Constants.FraudStatusPaymentField), Common.Constants.OtherPaymentClass);
}
private MetaField GetOrCreateField(
MetaDataContext mdContext,
string metaNamespace,
string fieldName,
string friendlyName,
MetaDataType metaDataType = MetaDataType.LongString)
{
return(MetaField.Load(mdContext, fieldName) ?? MetaField.Create(mdContext, metaNamespace,
fieldName, friendlyName, string.Empty, metaDataType, Int32.MaxValue, true, false, false, false));
}
public VariationMappingMetaClass(MetaDataContext context, string metaClassName, int CatalogId)
: base(context)
{
MetaClass mc = MetaClass.Load(context, metaClassName);
_isSystemClass = mc.IsSystem;
InnerMetaClassName = mc.Name;
_metaClassId = mc.Id;
_CatalogId = CatalogId;
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="context"></param>
public void Initialize(InitializationEngine context)
{
MetaDataContext mdContext = CatalogContext.MetaDataContext;
var callbackUrl = GetOrCreateCardField(mdContext, NetaxeptConstants.CallbackUrl);
JoinField(mdContext, callbackUrl, NetaxeptConstants.OtherPaymentClass);
var cardInformationIssuerCountryField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationIssuerCountryField);
JoinField(mdContext, cardInformationIssuerCountryField, NetaxeptConstants.OtherPaymentClass);
var cardInformationExpiryDateField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationExpiryDateField);
JoinField(mdContext, cardInformationExpiryDateField, NetaxeptConstants.OtherPaymentClass);
var cardInformationIssuerField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationIssuerField);
JoinField(mdContext, cardInformationIssuerField, NetaxeptConstants.OtherPaymentClass);
var cardInformationIssuerIdField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationIssuerIdField);
JoinField(mdContext, cardInformationIssuerIdField, NetaxeptConstants.OtherPaymentClass);
var cardInformationMaskedPanField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationMaskedPanField);
JoinField(mdContext, cardInformationMaskedPanField, NetaxeptConstants.OtherPaymentClass);
var cardInformationPaymentMethodField = GetOrCreateCardField(mdContext, NetaxeptConstants.CardInformationPaymentMethodField);
JoinField(mdContext, cardInformationPaymentMethodField, NetaxeptConstants.OtherPaymentClass);
var cartOrderNumberTempField = GetOrCreateCardField(mdContext, NetaxeptConstants.CartOrderNumberTempField);
JoinField(mdContext, cartOrderNumberTempField, NetaxeptConstants.CartClass);
// Create PanHash field on the customer contact. We need this for using EasyPayments
var customContactMetaClass = DataContext.Current.MetaModel.MetaClasses["Contact"];
if (customContactMetaClass != null)
{
using (MetaFieldBuilder builder = new MetaFieldBuilder(customContactMetaClass))
{
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerPanHashFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardMaskedFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardExpirationDateFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardPaymentMethodFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardIssuerCountryFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardIssuerIdFieldName);
AddCustomerField(builder, customContactMetaClass, NetaxeptConstants.CustomerCardIssuerFieldName);
builder.SaveChanges();
}
}
}
protected MetaField GetOrCreateCardField(MetaDataContext mdContext, string fieldName, MetaDataType metaDataType = MetaDataType.LongString)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
Logger.Debug($"Adding meta field '{fieldName}' for {IntegrationName} integration.");
f = MetaField.Create(mdContext, Common.Constants.OrderNamespace, fieldName, fieldName, string.Empty, metaDataType, Int32.MaxValue, true, false, false, false);
}
return(f);
}
/// <summary>
/// Get or create card field
/// </summary>
/// <param name="mdContext"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
private MetaField GetOrCreateCardField(MetaDataContext mdContext, string fieldName)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
Logger.Debug(string.Format("Adding meta field '{0}' for Netaxept integration.", fieldName));
f = MetaField.Create(mdContext, NetaxeptConstants.OrderNamespace, fieldName, fieldName, string.Empty, MetaDataType.LongString, Int32.MaxValue, true, false, false, false);
}
return(f);
}
public void Initialize(InitializationEngine context)
{
MetaDataContext mdContext = CatalogContext.MetaDataContext;
var reservation = GetOrCreateReservationField(mdContext);
JoinField(mdContext, reservation, MetadataConstants.OtherPaymentClass);
var invoiceNumber = GetOrCreateInvoiceField(mdContext);
JoinField(mdContext, invoiceNumber, MetadataConstants.PurchaseOrderClass);
}
protected MetaField GetOrCreateMetaField(MetaDataContext mdContext, string fieldName, MetaDataType metaDataType = MetaDataType.LongString, int length = int.MaxValue)
{
var field = MetaField.Load(mdContext, fieldName);
if (field != null)
{
return(field);
}
return(CreateMetaField(mdContext, fieldName, metaDataType, length));
}
public VariationMappingMetaClass(MetaDataContext context, int CatalogId)
: base(context)
{
InnerMetaClassName = "CatalogEntry";
MetaClass mc = MetaClass.Load(context, InnerMetaClassName);
_isSystemClass = mc.IsSystem;
_metaClassId = mc.Id;
_CatalogId = CatalogId;
}
private void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (!MetaFieldIsNotConnected(field, cls))
{
return;
}
cls.AddField(field);
}
public CategoryMappingMetaClass(MetaDataContext context, int CatalogId)
: base(context)
{
InnerMetaClassName = "CatalogNode";
MetaClass mc = MetaClass.Load(context, InnerMetaClassName);
_isSystemClass = mc.IsSystem;
_metaClassId = mc.Id;
_CatalogId = CatalogId;
}
private void UpdateCartMetaFields()
{
MetaDataContext mdContext = OrderContext.MetaDataContext;
var successRedirectUrl = GetOrCreateMetaField(mdContext, MetaDataConstants.OrderNamespace, MetaDataConstants.SuccessRedirectUrl, "Cart success redirect URL", MetaDataType.ShortString, true, false);
JoinField(mdContext, successRedirectUrl, MetaDataConstants.ShoppingCartClass);
var failRedirectUrl = GetOrCreateMetaField(mdContext, MetaDataConstants.OrderNamespace, MetaDataConstants.FailRedirectUrl, "Cart failure redirect URL", MetaDataType.ShortString, true, false);
JoinField(mdContext, failRedirectUrl, MetaDataConstants.ShoppingCartClass);
}
public virtual MetaField GetOrCreateMetaField(MetaDataContext mdContext, string metaNamespace, string fieldName, string friendlyName, MetaDataType metadataType, bool allowNulls, bool multiLanguage)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
f = MetaField.Create(mdContext, metaNamespace, fieldName, friendlyName, string.Empty, metadataType, 0, allowNulls, multiLanguage, false, false);
}
return(f);
}
private void JoinField(MetaDataContext mdContext, MetaField field, IEnumerable <string> metaClassNames)
{
foreach (var metaClassName in metaClassNames)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
}
private MetaField GetOrCreateInvoiceField(MetaDataContext mdContext)
{
var f = MetaField.Load(mdContext, MetadataConstants.InvoiceId);
if (f == null)
{
Logger.Debug(string.Format("Adding meta field '{0}' for Klarna integration.", MetadataConstants.InvoiceId));
f = MetaField.Create(mdContext, MetadataConstants.OrderNamespace, MetadataConstants.InvoiceId, MetadataConstants.InvoiceId, string.Empty, MetaDataType.ShortString, 100, true, false, false, false);
}
return(f);
}
private MetaField GetOrCreateMetaField(MetaDataContext mdContext, string fieldName, string friendlyName, MetaDataType metadataType)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
Logger.Debug(string.Format("Adding meta field '{0}' for Verifone payment integration.", fieldName));
f = MetaField.Create(mdContext, MetadataConstants.OrderNamespace, fieldName, friendlyName, string.Empty, metadataType, 0, true, false, false, false);
}
return(f);
}
private MetaClass GetOrCreateMetaClass(MetaDataContext mdContext, string metaNamespace, string className, string friendlyName, string tableName, string parentClass)
{
var mc = MetaClass.Load(mdContext, className);
if (mc == null)
{
Logger.Debug(string.Format("Creating MetaClass '{0}' for Paypal payment integration.", className));
var parent = MetaClass.Load(mdContext, parentClass);
mc = MetaClass.Create(mdContext, metaNamespace, className, friendlyName, tableName, parent, false, string.Empty);
}
return(mc);
}
public void Initialize(InitializationEngine context)
{
MetaDataContext mdContext = CatalogContext.MetaDataContext;
var paypalPayment = GetOrCreateMetaClass(mdContext, MetadataConstants.UsersNameSpace, MetadataConstants.PayPalClassName, "PayPal payment", MetadataConstants.PayPalTableName, MetadataConstants.OrderFormPaymentClass);
var expToken = GetOrCreateMetaField(mdContext, MetadataConstants.PayPalExpToken, "PayPal Exp token", MetaDataType.ShortString);
JoinField(mdContext, expToken, MetadataConstants.PayPalClassName);
var ordernumber = GetOrCreateMetaField(mdContext, MetadataConstants.PayPalOrderNumber, "PayPal order number", MetaDataType.ShortString);
JoinField(mdContext, ordernumber, MetadataConstants.PayPalClassName);
}
/// <summary>
/// Updates meta field
/// </summary>
/// <param name="item">The data item.</param>
/// <returns></returns>
private void UpdateMetaField(CatalogEntryDto.CatalogEntryRow item)
{
int MetaClassId = item.MetaClassId;
int ObjectId = item.CatalogEntryId;
MetaDataContext MDContext = CatalogContext.MetaDataContext;
if (ObjectId != 0)
{
// set username here, because calling FrameworkContext.Current.Profile causes MeteDataContext.Current to change (it's bug in ProfileContext class).
string userName = FrameworkContext.Current.Profile.UserName;
MDContext.UseCurrentUICulture = false;
MDContext.Language = LanguageCode;
MetaObject metaObj = null;
bool saveChanges = true;
metaObj = MetaObject.Load(MDContext, ObjectId, MetaClassId);
if (metaObj == null)
{
metaObj = MetaObject.NewObject(MDContext, ObjectId, MetaClassId, userName);
//DataBind(); return;
}
else
{
metaObj.ModifierId = userName;
metaObj.Modified = DateTime.UtcNow;
}
foreach (Control ctrl in MetaControls.Controls)
{
// Only update controls that belong to current language
if (String.Compare(((IMetaControl)ctrl).LanguageCode, LanguageCode, true) == 0)
{
((IMetaControl)ctrl).MetaObject = metaObj;
//((IMetaControl)ctrl).MetaField = metaObj;
((IMetaControl)ctrl).Update();
}
}
// Only save changes when new object has been created
if (saveChanges)
{
metaObj.AcceptChanges(MDContext);
}
MDContext.UseCurrentUICulture = true;
}
}
public void Initialize(InitializationEngine context)
{
MetaDataContext mdContext = CatalogContext.MetaDataContext;
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.KlarnaSessionIdCartField), Common.Constants.CartClass);
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.KlarnaClientTokenCartField), Common.Constants.CartClass);
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.KlarnaAllowSharingOfPersonalInformationCartField, MetaDataType.Boolean), Common.Constants.CartClass);
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.CartOrderNumberTempCartField), Common.Constants.CartClass);
JoinField(mdContext, GetOrCreateCardField(mdContext, Common.Constants.KlarnaOrderIdField), Common.Constants.CartClass);
// Other payment meta fields
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.KlarnaConfirmationUrlPaymentField), Common.Constants.OtherPaymentClass);
JoinField(mdContext, GetOrCreateCardField(mdContext, Constants.AuthorizationTokenPaymentField), Common.Constants.OtherPaymentClass);
}
private MetaField CreateMetaField(MetaDataContext mdContext, string metaDataNamespace, string metaFieldName, MetaDataType type, int length, bool allowNulls, bool cultureSpecific, int optScale = 2, int optPrecision = 18)
{
var metaField = MetaField.Load(mdContext, metaFieldName) ??
MetaField.Create(mdContext, metaDataNamespace, metaFieldName, metaFieldName, string.Empty, type, length, allowNulls, cultureSpecific, false, false);
if (type != MetaDataType.Decimal)
{
return(metaField);
}
metaField.Attributes[MetaFieldAttributeConstants.MdpPrecisionAttributeName] = optPrecision.ToString();
metaField.Attributes[MetaFieldAttributeConstants.MdpScaleAttributeName] = optScale.ToString();
return(metaField);
}
/// <summary>
/// Initializes a new instance of the <see cref="CatalogContext"/> class.
/// </summary>
/// <param name="context">The context.</param>
public CatalogContextImpl(MetaDataContext context)
{
// Perform auto configuration
if (CatalogConfiguration.Instance.AutoConfigure)
{
// Check if we already configured meta data
MetaClass metaClass = MetaClass.Load(context, "CatalogEntry");
// Setup meta data
if (metaClass == null)
{
CatalogConfiguration.ConfigureMetaData();
}
}
}
/// <summary>
/// Creates the update command.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
protected virtual DataCommand CreateUpdateCommand(MetaDataContext context)
{
string tableName = SystemMetaClass.TableName;
DataCommand cmd = new DataCommand();
cmd.CommandText = DataHelper.CreateUpdateStoredProcedureName(tableName);
cmd.CommandType = CommandType.StoredProcedure;
if (context != null)
{
cmd.ConnectionString = context.ConnectionString;
}
cmd.Parameters = new DataParameters();
CreateParameters(cmd);
return(cmd);
}
public CatalogIndexer(ICatalogSystem catalogSystem,
IPriceService priceService,
IPricingService pricingService,
IInventoryService inventoryService,
MetaDataContext metaDataContext,
AssetUrlResolver assetUrlResolver,
ILogger logger,
CatalogContentService catalogContentService)
: base(catalogSystem, priceService, inventoryService, metaDataContext)
{
_pricingService = pricingService;
_assetUrlResolver = assetUrlResolver;
_log = logger;
_catalogContentService = catalogContentService;
}
public RestIndexer(
ICatalogSystem catalogSystem,
IPriceService priceService,
IInventoryService inventoryService,
MetaDataContext metaDataContext,
CatalogItemChangeManager catalogItemChangeManager,
NodeIdentityResolver nodeIdentityResolver)
: base(
catalogSystem,
priceService,
inventoryService,
metaDataContext,
catalogItemChangeManager,
nodeIdentityResolver)
{
_url = VirtualPathUtility.AppendTrailingSlash(ConfigurationManager.AppSettings["SearchApiUrl"]);
}
public void Initialize(InitializationEngine context)
{
var metadataInfo = GetMetadataInfos();
MetaDataContext mdContext = CatalogContext.MetaDataContext;
CreateMetaClass(mdContext, Constants.Metadata.OrderFormPayment.ClassName, Constants.Metadata.Namespace.User, Constants.Metadata.Payment.PayExPaymentClassName,
Constants.Metadata.Payment.PayExPaymentTableName, string.Empty);
CreateMetaClass(mdContext, Constants.Metadata.OrderFormPayment.ClassName, Constants.Metadata.Namespace.User, Constants.Metadata.Payment.ExtendedPayExPaymentClassName,
Constants.Metadata.Payment.ExtendedPayExPaymentTableName, string.Empty);
foreach (var item in metadataInfo)
{
var metaField = CreateMetaField(mdContext, item.MetadataNamespace, item.MetaFieldName, item.Type, item.Length, item.AllowNulls, item.CultureSpecific);
JoinField(mdContext, metaField, item.ClassNames);
}
}
/// <summary>
/// Processes the import button event.
/// </summary>
protected void DoImport()
{
// save current MetaDataContext
MetaDataContext currentContext = OrderContext.MetaDataContext;
try
{
string filePath = SelectedFilePath;
if (String.IsNullOrEmpty(filePath))
{
throw new Exception("No selected file.");
}
// import taxes
try
{
_ImportExport.ImportExportProgressMessage += new Mediachase.Commerce.Orders.ImportExport.TaxImportExportProgressMessageHandler(ImportExport_ImportExportProgressMessage);
// perform import operation
_ImportExport.Import(SelectedFilePath, GetCurrentApplicationId(), null, ',');
SelectedFilePath = null;
}
catch (Mediachase.Commerce.Orders.ImportExport.OrdersImportExportException ex)
{
throw ex;
}
catch (Exception ex1)
{
throw ex1;
}
finally
{
}
}
catch (Exception ex)
{
ProgressControl1.AddProgressMessageText(ex.Message, true, -1);
}
finally
{
}
}
public static void ExecuteScript(MetaDataContext context, string script)
{
#if DEBUG
System.Diagnostics.Trace.WriteLine(script, "ExecuteScript");
#endif
using (System.IO.StringReader reader = new System.IO.StringReader(script))
{
bool bContueRead = true;
StringBuilder sqlCommandText = new StringBuilder();
while (bContueRead)
{
while (true)
{
string line = reader.ReadLine();
if (line == null)
{
bContueRead = false;
break;
}
string trimLine = line.Trim();
if (!string.IsNullOrEmpty(trimLine))
{
if (string.Compare(trimLine, "GO", true) == 0)
break;
else
{
sqlCommandText.Append(line);
sqlCommandText.Append("\r\n");
}
}
}
if (sqlCommandText.Length > 0)
{
SqlHelper.ExecuteNonQuery(context, CommandType.Text, sqlCommandText.ToString());
sqlCommandText = new StringBuilder();
}
}
}
}
public static SqlDataReader ExecuteReader(MetaDataContext context, CommandType commandType, string commandText)
{
return ExecuteReader(context, commandType, commandText, (SqlParameter[])null);
}
public static DataSet ExecuteDataset(MetaDataContext context, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of SqlParameters
return ExecuteDataset(context, commandType, commandText, (SqlParameter[])null);
}
