private void ProcessEmailJobStatus(string emailAddresses, AryaTask job, bool includeLogUrl, string customStatus = null)
{
var emailAddress = emailAddresses;
var projectName = string.Empty;
try
{
using (var aryaDb = new AryaDbDataContext(job.ProjectID, job.SubmittedBy))
{
if (string.IsNullOrWhiteSpace(emailAddress))
{
emailAddress = aryaDb.CurrentUser.EmailAddress;
}
projectName = aryaDb.CurrentProject.ProjectName;
}
}
catch (UnauthorizedAccessException e)
{
CurrentLogWriter.Warn(e.Message);
}
try
{
AryaServices.SendEmail(job, includeLogUrl, customStatus, projectName, emailAddress, Settings.Default.PortalLocation);
}
catch (Exception ex)
{
CurrentLogWriter.Error(String.Format("Email sending has failed. {0} has occured. Details{1}",
ex.GetType(), ex.StackTrace));
}
}
protected void LoadExistingImportFields()
{
var connStr = Util.GetAryaServicesConnectionString();
var sqlConnection = new SqlConnection(connStr);
var basepath = ConfigurationManager.AppSettings["BasePath"];
var id = Request.QueryString["ID"];
var projectID = Request.QueryString["ProjectID"];
using (var Dc = new AryaDbDataContext())
{
var projectName = (from p in Dc.Projects
where p.ID == Guid.Parse(projectID)
select p.ClientDescription + ' ' + p.SetName).Single();
ddlProject.SelectedItem.Text = projectName;
}
projectId.Value = projectID;
//string description = Session["Description"].ToString();
//txtProjectDesc.Text = description;
var cmd1 = new SqlCommand();
cmd1.CommandText = "Select ArgumentDirectoryPath from AryaTask Where ID= @id";
cmd1.CommandType = CommandType.Text;
cmd1.Parameters.Add("@ID", SqlDbType.UniqueIdentifier).Value = Guid.Parse(id);
//cmd1.Parameters.Add("@Description", SqlDbType.VarChar).Value = description;
sqlConnection.Close();
cmd1.Connection = sqlConnection;
sqlConnection.Open();
var xmlpathValue = cmd1.ExecuteScalar().ToString();
var path = Path.Combine(basepath, xmlpathValue);
var ArgumentDirectoryPath = Path.Combine(path, WorkerArguments.ArgumentsFileName);
ReadDataFromXMLFile(ArgumentDirectoryPath);
sqlConnection.Close();
}
private void AddTaxonomyToDataTable(Guid exportTaxonomyId)
{
using (var dc = new AryaDbDataContext(Args.ProjectId, Args.UserId))
{
var taxonomyInfo = dc.TaxonomyInfos.FirstOrDefault(ti => ti.ID == exportTaxonomyId);
if (taxonomyInfo != null)
{
var taxPath = taxonomyInfo.ToString();
if (Args.IgnoreT1Taxonomy)
{
taxPath = taxonomyInfo.ToString(true);// taxPath.Substring(taxPath.IndexOf('>') + 1);
}
if (string.IsNullOrEmpty(taxPath))
{
return;
}
var attributes = GetAttributes(dc, taxonomyInfo);
var isLeafNode = taxonomyInfo.IsLeafNode;
//if a node has no schema, just skip it.
if ((attributes.Count == 0) || (Args.LeafNodesOnly && isLeafNode == false))
{
//StatusMessage = string.Format("{1}{0}, Fetching Child Nodes", Environment.NewLine, exportTaxonomyId);
//var taxonomies =
// taxonomyInfo.ChildTaxonomyDatas.Where(td => td.Active)
// .Select(td => td.TaxonomyInfo)
// .OrderBy(tax => tax.ToString());
//foreach (var tax in taxonomies)
// AddTaxonomyToDataTable(tax.ID);
//CurrentProgress++;
return;
}
foreach (var attribute in attributes)
{
var schemaInfo = GetSchemaInfo(taxonomyInfo, attribute);
if (schemaInfo == null)
{
continue;
}
var row = SchemaExportData.NewRow();
foreach (DataColumn metaAttributeColumn in SchemaExportData.Columns)
{
var cellValue = GetColumnValue(dc, schemaInfo, metaAttributeColumn.ColumnName);
if (!string.IsNullOrEmpty(cellValue))
{
row[metaAttributeColumn] = cellValue;
continue;
}
row[metaAttributeColumn] = string.Empty;
}
SchemaExportData.Rows.Add(row);
}
} //end of if (taxonomyInfo != null)
} //end of using
}
private void dgv_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0 || dgv.Columns[ImageColumn] == null || e.ColumnIndex != dgv.Columns[ImageColumn].Index)
{
return;
}
using (
var dc = new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID);
if (!imageMgr.UploadImage())
{
return;
}
imageMgr.AddAttributeValue("LovId", _lovs[e.RowIndex].Id.ToString());
imageMgr.AddAttributeValue("TaxonomyId", SchemaInfo.TaxonomyID.ToString());
imageMgr.AddAttributeValue("AttributeId", SchemaInfo.AttributeID.ToString());
SchemaInfo.TaxonomyInfo.SkuInfos.Add(new SkuInfo {
SkuID = imageMgr.ImageSku.ID
});
AryaTools.Instance.SaveChangesIfNecessary(false, false);
dgv.Rows[e.RowIndex].Cells[ImageColumn].Value = imageMgr.RemoteImageGuid;
if (AryaTools.Instance.Forms.TreeForm.ShowEnrichments)
{
AryaTools.Instance.Forms.BrowserForm.DisplayImage(imageMgr);
}
}
}
private void ProcessTaxonomySkus(TaxonomyInfo node)
{
try
{
//Must use independent DataContext to conserve memory
using (var dc = new AryaDbDataContext(Arguments.ProjectId, Arguments.UserId))
{
var allSkus = from si in dc.SkuInfos
where si.Active && si.TaxonomyID == node.ID
let sku = si.Sku
where sku.SkuType == Sku.ItemType.Product.ToString()
select sku;
var skus = ((AdvancedExportArgs)Arguments).GetFilteredSkuList(allSkus).Select(s => s.ID).ToList();
skus.AsParallel().ForAll(ProcessSku);
//skus.ForEach(ProcessSku);
}
}
catch (Exception exception)
{
var message = string.Empty;
var ex = exception;
while (ex != null)
{
message += ex.Message + Environment.NewLine;
message += ex.StackTrace + Environment.NewLine;
ex = ex.InnerException;
}
CurrentLogWriter.Warn("There was a problem processing skus in node." + Environment.NewLine + message);
}
}
public DerivedEntityData(AryaDbDataContext parentContext, bool initialize = true)
: this()
{
ParentContext = parentContext;
Initialize = initialize;
InitEntity();
}
public AttributeGroup(AryaDbDataContext parentContext, bool initialize = true)
: this()
{
ParentContext = parentContext;
Initialize = initialize;
InitEntity();
}
/// <summary>
/// Update Derived Attribute Values in this SKU
/// </summary>
/// <param name="sku"></param>
/// <param name="derivedAttributes"></param>
/// <param name="dc"></param>
private void ProcessSku(Sku sku, IEnumerable <Attribute> derivedAttributes, AryaDbDataContext dc)
{
var derivedValues = sku.DerivedEntityDatas.Where(ded => ded.Active).ToDictionary(d => d.AttributeID, d => d);
foreach (var att in derivedAttributes)
{
var value = sku.GetValuesForAttribute(dc, att, false).First().Value;
if (derivedValues.ContainsKey(att.ID))
{
if (derivedValues[att.ID].Value == value)
{
continue; //No change to the value, nothing to do here...
}
//Deactivate this value; we'll insert a new value later
derivedValues[att.ID].Active = false;
}
if (string.IsNullOrWhiteSpace(value))
{
continue;
}
sku.DerivedEntityDatas.Add(new DerivedEntityData(dc)
{
Attribute = att, Value = value
});
++_iValueCount;
}
++_iSkuCount;
}
private string GetTaxMetaAttributeValue(AryaDbDataContext dc, string taxMetaAttributeName,
TaxonomyInfo taxonomy)
{
var taxMetaData =
(dc.TaxonomyMetaDatas.FirstOrDefault(
tmd =>
tmd.TaxonomyMetaInfo.TaxonomyID.Equals(taxonomy.ID) &&
tmd.TaxonomyMetaInfo.MetaAttributeID.Equals(AllTaxMetaAttributes[taxMetaAttributeName].ID) &&
tmd.Active));
string value = taxMetaData == null ? string.Empty : taxMetaData.Value;
if (String.Compare(taxMetaAttributeName, Resources.TaxonomyEnrichmentImageAttributeName,
StringComparison.OrdinalIgnoreCase) == 0)
{
var imageMgr = new ImageManager(dc, Args.ProjectId, value)
{
LocalDirectory = ArgumentDirectoryPath,
RemoteImageGuid = value
};
//if (!Directory.Exists(imageMgr.LocalDirectory))
// Directory.CreateDirectory(imageMgr.LocalDirectory);
if (Args.DownloadAssets)
{
imageMgr.DownloadImage(taxonomy.ID);
}
value = imageMgr.OriginalFileName;
}
return(value);
}
protected override void FetchExportData()
{
try
{
StatusMessage = string.Format("Taxonomy Export worker has started");
var exportTaxonomyIds = new List <Guid>();
using (var dc = new AryaDbDataContext(Args.ProjectId, Args.UserId))
{
var taxs =
(from tax in dc.TaxonomyInfos where Args.TaxonomyIds.Contains(tax.ID) select tax).ToList();
exportTaxonomyIds.AddRange(taxs.Select(tx => tx.ID));
exportTaxonomyIds.AddRange(taxs.SelectMany(ti => ti.AllChildren).Select(tax => tax.ID).ToList());
}
foreach (var exportTaxonomyId in exportTaxonomyIds)
{
AddTaxonomyToDataTable(exportTaxonomyId);
}
ExportDataTables.Add(TaxonomyExportData);
State = WorkerState.Complete;
StatusMessage = string.Format("Taxonomy Export worker completed");
}
catch (Exception ex)
{
Summary.SetError(ex);
}
}
public UserProject(AryaDbDataContext parenteContext, bool initialize = true) : this()
{
ParentContext = parenteContext;
Initialize = initialize;
InitEntity();
GroupID = Group.DefaultGroupID;
}
private bool DuplicateTaxonomyIndb(ImportArgs importArgs)
{
using (var CurrentDbContext = new AryaDbDataContext(importArgs.ProjectId, importArgs.UserId))
{
return(CurrentDbContext.ExecuteQuery <string>(@"SELECT TaxonomyPath
FROM V_Taxonomy
WHERE TaxonomyPath <> ''
AND ProjectId = {0} GROUP BY TaxonomyPath Having Count(*) > 1", importArgs.ProjectId).Count() > 0);
}
}
private void BlankImageForm()
{
using (
var dc = new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID);
AryaTools.Instance.Forms.BrowserForm.DisplayImage(imageMgr);
}
}
protected void SelectProject()
{
var currentProject = ddlProject.SelectedItem.Value;
using (var Dc = new AryaDbDataContext())
{
var currentProjectID =
(from p in Dc.Projects where p.ClientDescription + ' ' + p.SetName == currentProject select p.ID)
.FirstOrDefault();
projectId.Value = currentProjectID.ToString();
}
}
private string GetDatabaseName(Guid projectId)
{
string results = String.Empty;
using (var dc = new AryaDbDataContext())
{
var project = dc.Projects.FirstOrDefault(p => p.ID == projectId);
if (project != null)
{
results = project.DatabaseName;
}
}
return(results);
}
private List <ItemInfo> GetItemValues(Guid taxId)
{
using (var dc = new AryaDbDataContext(_args.ProjectId, _args.UserId))
{
var taxonomy = dc.TaxonomyInfos.Where(ti => ti.ID == taxId).First();
var attributes = (from ti in dc.TaxonomyInfos
where ti.ID == taxId
from si in ti.SchemaInfos
from sd in si.SchemaDatas
where sd.Active && sd.InSchema
//let navOrder = sd.NavigationOrder == 0 ? 999 : sd.NavigationOrder
//let dispOrder = sd.DisplayOrder == 0 ? 999 : sd.DisplayOrder
//orderby navOrder, dispOrder
select si.Attribute.AttributeName).Distinct().ToList();
var values = (from si in dc.SkuInfos
where si.Active && si.TaxonomyID == taxId
from ed in dc.EntityDatas
let sku = ed.EntityInfo.Sku
let attributeName = ed.Attribute.AttributeName
where ed.Active && sku.ID == si.SkuID && attributes.Contains(attributeName)
select new { SkuID = sku.ID, sku.ItemID, AttributeName = attributeName, ed.Value, ed.Uom }).ToList();
var itemValues = from val in values
group val by val.ItemID
into grp
select
new ItemInfo
{
SkuId = grp.First().SkuID,
ItemId = grp.First().ItemID,
TaxonomyId = taxonomy.ID,
TaxonomyPath = taxonomy.ToString(_args.IgnoreT1Taxonomy),
SchemaValues = (from attVal in grp
group attVal by attVal.AttributeName
into attGrp
select
new
{
Attribute = attGrp.Key,
Values =
grp.Select(val => (val.Value + " " + (val.Uom ?? string.Empty)).Trim())
.ToList()
}).ToDictionary(av => av.Attribute, av => av.Values)
};
return(itemValues.ToList());
}
}
// Private Methods (2)
partial void OnActiveChanged()
{
if (Active)
{
return;
}
var parentContext = ParentContext;
if (parentContext == null)
{
return;
}
AryaDbDataContext.DefaultDeletedTableValue(this, parentContext.CurrentUser.ID);
}
private Dictionary <string, Attribute> GetAllTaxMetaAttributes()
{
var emptyGuid = new Guid();
var metaAttributes = new List <Attribute>();
List <Attribute> activeMetaAttributes = new List <Attribute>();
//var metaAttributes = new List<Attribute>();
if (Args.ExportEnrichments || Args.ExportMetaAttributes)
{
using (var dc = new AryaDbDataContext(Args.ProjectId, Args.UserId))
{
metaAttributes = (from att in dc.Attributes
where
att.ProjectID.Equals(dc.CurrentProject.ID) &&
att.AttributeType.Equals(AttributeTypeEnum.TaxonomyMeta.ToString()) &&
att.SchemaInfos.Any(si => si.SchemaDatas.Any(sd => sd.Active))
let displayRank = (from si in att.SchemaInfos
where si.TaxonomyID.Equals(emptyGuid)
from sd in si.SchemaDatas
where sd.Active
select sd.DisplayOrder).FirstOrDefault()
orderby displayRank, att.AttributeName
select att).ToList();
foreach (var metaAttribute in metaAttributes)
{
var si = metaAttribute.SchemaInfos.FirstOrDefault(s => s.TaxonomyID.Equals(Guid.Empty));
if (si != null && si.SchemaData.InSchema)
{
activeMetaAttributes.Add(metaAttribute);
}
}
//remove enrichment
if (!Args.ExportEnrichments)
{
activeMetaAttributes = activeMetaAttributes.Where(s => !Attribute.TaxonomyEnrichmentAttributes.Contains(s.AttributeName)).ToList();
}
if (!Args.ExportMetaAttributes)
{
activeMetaAttributes =
activeMetaAttributes.Where(
s =>
s.AttributeType != AttributeTypeEnum.TaxonomyMeta.ToString() ||
Attribute.TaxonomyEnrichmentAttributes.Contains(s.AttributeName)).ToList();
}
//metaAttributeNames = metaAttributeNames.Select(ta => ta.AttributeName).ToList();
} //end of using
}
return(activeMetaAttributes.ToDictionary(ma => ma.AttributeName, ma => ma));
}
protected void DisplayProjectList()
{
var availableProjects = new List <ListItem>();
using (var Dc = new AryaDbDataContext())
{
var currUser =
(from u in Dc.Users where u.EmailAddress == ((SiteMaster)Page.Master).Email select u)
.FirstOrDefault();
var userID = currUser.ID;
var userName = currUser.FullName;
var userRole = currUser.IsAdmin;
userId.Value = userID.ToString();
var existingDatabases = Dc.ExecuteQuery <string>("select name from sys.databases").ToList();
if (!userRole)
{
var projects = (from ug in currUser.UserProjects
where
ug.GroupID == Group.ImportAdminGroup ||
ug.GroupID == Group.ImportUserGroup &&
existingDatabases.Contains(ug.Project.DatabaseName)
orderby ug.Project.DatabaseName ascending
select ug.Project).Distinct();
availableProjects =
projects.Select(p => new ListItem {
Text = p.ClientDescription + " " + p.SetName
}).ToList();
}
else
{
var projects =
(from p in Dc.Projects
where existingDatabases.Contains(p.DatabaseName)
orderby p.DatabaseName ascending
select p);
availableProjects =
projects.Select(p => new ListItem {
Text = p.ClientDescription + " " + p.SetName
})
.Distinct()
.ToList();
}
ddlProject.Items.Insert(0, "Select a Project");
availableProjects.ForEach(ap => ddlProject.Items.Add(ap));
}
}
private void WriteTaxMetaValue(TaxonomyInfo taxonomy)
{
foreach (var taxMetaAttribute in _taxMetaAttributes)
{
var rawAttributeValue = GetValue(taxMetaAttribute, taxonomy);
string finalAttributeValue = rawAttributeValue;
if (ExportEnrichments)
{
if (taxMetaAttribute.ToString() == Resources.TaxonomyEnrichmentCopyAttributeName)
{
// replace carriage returns with "|"
if (!String.IsNullOrEmpty(rawAttributeValue))
{
var returnChar =
AryaTools.Instance.InstanceData.CurrentProject.ProjectPreferences.ReturnSeparator ?? "|";
finalAttributeValue = rawAttributeValue.Replace("\r", String.Empty).Replace("\n", returnChar);
}
}
else if (taxMetaAttribute.ToString() == Resources.TaxonomyEnrichmentImageAttributeName)
{
using (var dc =
new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID)
{
ImageSku = dc.Skus.FirstOrDefault(s => s.ItemID == rawAttributeValue)
};
// retrieve Enrichment Image, if it exists
if (DownloadAssets)
{
imageMgr.LocalDirectory = _downloadDir.ToString();
imageMgr.DownloadImage(taxonomy.ID);
finalAttributeValue = imageMgr.LocalImageName;
}
else
{
finalAttributeValue = imageMgr.RemoteImageUrl;
}
}
}
}
_taxFile.Write("{0}{1}", _delimiter, finalAttributeValue);
}
_taxFile.WriteLine();
}
private string GetColumnValue(AryaDbDataContext dc, TaxonomyInfo taxonomyInfo, string columnName)
{
if (_taxColumns.Contains(columnName))
{
if (columnName == "Taxonomy")
{
return(taxonomyInfo.ToString(Args.IgnoreT1Taxonomy));
}
return(GetTn(taxonomyInfo, columnName));
}
if (columnName == "NodeDescription")
{
return(taxonomyInfo.TaxonomyData.NodeDescription);
}
return(GetTaxMetaAttributeValue(dc, columnName, taxonomyInfo));
}
private static IEnumerable <AryaTask> GetTasks(AryaDbDataContext aryaDc,
AryaServicesDbDataContext taskDc, User currUser, Guid userGroup, IEnumerable <string> jobTypes,
bool currentUserTasksOnly)
{
var projects =
(from ug in aryaDc.UserProjects
where ug.GroupID == userGroup && ug.UserID == currUser.ID
select ug.ProjectID).ToList();
return(projects.Any()
? taskDc.AryaTasks.Where(
task =>
projects.Contains(task.ProjectID) && jobTypes.Contains(task.JobType) &&
(!currentUserTasksOnly || task.SubmittedBy == currUser.ID))
: Enumerable.Empty <AryaTask>());
}
private IEnumerable <Attribute> GetAttributes(AryaDbDataContext dc, TaxonomyInfo currentTaxonomyInfo)
{
var attributes = new List <Attribute>();
if (Args.LeafNodesOnly && !currentTaxonomyInfo.IsLeafNode)
{
return(attributes);
}
if (currentTaxonomyInfo.GetSkus(Args.ExportCrossListNodes).Any(t => t.SkuType == "Product") || Args.ExportEmptyNodes)
{
if (!currentTaxonomyInfo.IsLeafNode)
{
var schemaInfos = new List <SchemaInfo>();
schemaInfos.AddRange(
currentTaxonomyInfo.SchemaInfos.Where(si => si.SchemaDatas.Any(sd => sd.Active)).ToList());
var schemaAttributes =
schemaInfos.Where(p => p.SchemaData.InSchema).Select(p => new { p.Attribute, p.SchemaData }).ToList();
attributes = (from att in schemaAttributes
group att by att.Attribute
into grp
let minRank = grp.Min(p => GetRank(p.SchemaData, SortOrder.OrderbyDisplayNavigation))
orderby minRank
select grp.Key).Distinct().ToList();
}
else
{
attributes = (from si in dc.SchemaInfos
where si.TaxonomyID == currentTaxonomyInfo.ID
let sd = si.SchemaDatas.FirstOrDefault(sd => sd.Active)
where sd != null
let inSchema = sd.InSchema
where inSchema
let navRank = sd == null || sd.NavigationOrder == 0 ? decimal.MaxValue : sd.NavigationOrder
let dispRank = sd == null || sd.DisplayOrder == 0 ? decimal.MaxValue : sd.DisplayOrder
orderby navRank, dispRank
select si.Attribute).ToList();
}
return(attributes);
}
return(attributes);
}
private void ProcessSku(ItemNode node, Sku sku)
{
try
{
using (var dc = new AryaDbDataContext(Arguments.ProjectId, Arguments.UserId))
{
var dbItem = dc.Skus.Single(s => sku.ID == s.ID);
var psp = (from ei in dbItem.EntityInfos
from ed in ei.EntityDatas
where
ed.Active &&
(ed.Attribute.AttributeName.ToLower().Contains("primary keyword") ||
ed.Attribute.AttributeName.ToLower().Contains("psp"))
orderby ed.Attribute.AttributeName descending
select ed.Value).FirstOrDefault() ?? "Item " + dbItem.ItemID;
var resultItem = Item.FromValues(node, dbItem.ID, dbItem.ItemID, psp);
ProcessAttributeValues(dbItem, resultItem);
resultItem.SerializeObject(GetSaveFilePath("Item", dbItem.ID.ToString()));
}
}
catch (Exception ex)
{
var message = Environment.NewLine + "Method: ProcessSku";
var e = ex;
while (e != null)
{
message = Environment.NewLine + e.Message;
e = e.InnerException;
}
CurrentLogWriter.Error(ex.Source + message + Environment.NewLine + ex.StackTrace);
if (Summary.Warnings == null)
{
Summary.Warnings = new List <WorkerWarning>();
}
Summary.Warnings.Add(new WorkerWarning
{
ErrorMessage = ex.Message,
ErrorDetails = ex.StackTrace,
LineData = sku.ItemID
});
}
}
private void FetchProjects()
{
using (var dc = new AryaDbDataContext())
{
var currUser =
(from u in dc.Users where u.EmailAddress == ((SiteMaster)Page.Master).Email select u)
.FirstOrDefault();
if (currUser == null)
{
throw new UnauthorizedAccessException();
}
UserId.Value = currUser.ID.ToString();
var p = currUser.IsAdmin
? dc.Projects
: currUser.UserProjects.Where(
dp =>
dp.GroupID == Group.ExportAdminGroup || dp.GroupID == Group.StandardExportUserGroup ||
dp.GroupID == Group.CustomExportUserGroup).Select(dp => dp.Project);
var existingDatabases = dc.ExecuteQuery <string>("SELECT LOWER(name) FROM sys.databases").ToList();
p = p.Where(dp => existingDatabases.Contains(dp.DatabaseName.ToLower())).Select(dp => dp);
var availableProjects =
p.Select(
dp =>
new ListItem
{
Text = string.Format("{0} {1}", dp.ClientDescription, dp.SetName),
Value = dp.ID.ToString()
}).Distinct().OrderBy(li => li.Text).ToList();
availableProjects.Insert(0, new ListItem("---Select a Model---", "---Select a Model---"));
ddlModel.DataSource = availableProjects;
ddlModel.DataBind();
if (availableProjects.Count == 1)
{
ddlModel.SelectedIndex = 1;
FetchExportTypes();
}
}
}
protected override void FetchExportData()
{
CurrentLogWriter.Info("Fetching SKUs");
_args = (ExportArgs)Arguments;
List <Guid> allTaxIds;
using (var dc = new AryaDbDataContext(_args.ProjectId, _args.UserId))
{
var taxIds = (from ti in dc.TaxonomyInfos where _args.TaxonomyIds.Contains(ti.ID) select ti).ToList();
allTaxIds = taxIds.SelectMany(ti => ti.AllChildren).Select(ti => ti.ID).ToList();
}
_iNodeCount = allTaxIds.Count;
allTaxIds.ForEach(ProcessNode);
//allTaxIds.AsParallel().ForAll(ProcessNode);
//_args.ItemIds.AsParallel().ForAll(sourceItemId => ProcessItem(sourceItemId));
CurrentLogWriter.Info("Saving Results");
ExportDataTables.Add(DuplicateSkusTable);
}
private void dgv_CellEnter(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0 || dgv.Columns[ImageColumn] == null ||
!AryaTools.Instance.Forms.TreeForm.ShowEnrichments)
{
return;
}
// TaxonomyInfo taxonomy = SchemaInfo.TaxonomyInfo;
if (dgv[dgv.Columns[ImageColumn].Index, e.RowIndex].Value != null)
{
var image = _lovs[e.RowIndex].EnrichmentImageId;
if (!string.IsNullOrEmpty(image))
{
using (
var dc = new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID)
{
ImageSku = dc.Skus.FirstOrDefault(sku => sku.ItemID == image)
};
AryaTools.Instance.Forms.BrowserForm.DisplayImage(imageMgr);
}
}
else
{
BlankImageForm();
}
}
else
{
using (
var dc = new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID);
AryaTools.Instance.Forms.BrowserForm.DisplayImage(imageMgr);
}
}
}
/// <summary>
/// Process each SKU Set separately (using a new Data Context)
/// </summary>
/// <param name="skuSet"></param>
private void ProcessSkuSet(List <Guid> skuSet)
{
using (var dc = new AryaDbDataContext(Arguments.ProjectId, Arguments.UserId))
{
//Get all Derived attributes
var derivedAttributes =
dc.Attributes.Where(att => att.AttributeType == AttributeTypeEnum.Derived.ToString()).ToList();
var skus = dc.Skus.Where(sku => skuSet.Contains(sku.ID));
var iCtr = 0;
if (Summary.Warnings == null)
{
Summary.Warnings = new List <WorkerWarning>();
}
//var dbCommand = dc.GetCommand(skus);
//Summary.Warnings.Add(new WorkerWarning { ErrorDetails = dbCommand.CommandText });
//foreach (DbParameter parameter in dbCommand.Parameters)
//{
// Summary.Warnings.Add(new WorkerWarning
// {
// ErrorMessage = parameter.ParameterName,
// ErrorDetails = parameter.Value.ToString()
// });
//}
foreach (var sku in skus)
{
ProcessSku(sku, derivedAttributes, dc);
if (++iCtr % 100 != 0)
{
continue;
}
dc.SubmitChanges();
StatusMessage = string.Format("{0} SKUs processed, {1} Values inserted/updated.", _iSkuCount, _iValueCount);
}
dc.SubmitChanges();
StatusMessage = string.Format("{0} SKUs processed, {1} Values inserted/updated.", _iSkuCount, _iValueCount);
}
}
private void UpdateDerivedEntities()
{
State = WorkerState.Working;
StatusMessage = "Init";
//Set the current Db - this will only be used for High Level processing
//Using the same Datacontext for all work is causing OutOfMemory Exception
//So, I'll have to use a bunch of 'worker' datacontexts
using (var dc = new AryaDbDataContext(Arguments.ProjectId, Arguments.UserId))
{
var skuSets = GetSkuSets(dc);
foreach (var skuSet in skuSets)
{
ProcessSkuSet(skuSet);
}
}
State = WorkerState.Complete;
}
private void ProcessTaxonomySkus(TaxonomyInfo ti)
{
//Must use independent DataContext to conserve memory
using (var dc = new AryaDbDataContext(Arguments.ProjectId, Arguments.UserId))
{
var node = ItemNode.FromValues(ti.ID, ti.ProjectID,
ti.ToString(((AdvancedExportArgs)Arguments).IgnoreT1Taxonomy), ti.NodeName);
//var allSkus = from si in dc.SkuInfos
// where si.Active && si.TaxonomyID == ti.ID
// let sku = si.Sku
// where sku.SkuType == Sku.ItemType.Product.ToString()
// select sku;
var allSkus = ti.GetSkus(_args.ExportCrossListNodes);
var skus = ((AdvancedExportArgs)Arguments).GetFilteredSkuList(allSkus).ToList();
skus.AsParallel().ForAll(sku => ProcessSku(node, sku));
}
}
