/// <summary>
/// Method to insert record
/// </summary>
/// <returns></returns>
public bool Add()
{
using (var context = new SGGSEntities())
{
var trim = new SGGS_CODE_TRIM_FORMAT
{
DATE_ADDED = DateTime.Now,
DATE_UPDATED = DateTime.Now,
TRIM_FORMAT_HEIGHT_IN = TRIM_FORMAT_HEIGHT_IN,
TRIM_FORMAT_HEIGHT_MM = TRIM_FORMAT_HEIGHT_MM,
TRIM_FORMAT_NAME = TRIM_FORMAT_NAME,
TRIM_FORMAT_NUMBER = TRIM_FORMAT_NUMBER,
TRIM_FORMAT_WIDTH_IN = TRIM_FORMAT_WIDTH_IN,
TRIM_FORMAT_WIDTH_MM = TRIM_FORMAT_WIDTH_MM,
USAGE_HARDCOVER = USAGE_HARDCOVER,
USAGE_PAPERBACK = USAGE_PAPERBACK,
SOFT_COVER = SOFT_COVER,
HARD_COVER = HARD_COVER
};
context.SGGS_CODE_TRIM_FORMAT.AddObject(trim);
context.SaveChanges();
TRIM_FORMAT_ID = trim.TRIM_FORMAT_ID;
return(true);
}
}
/// <summary>
/// Method to Load values from DB by group Id
/// </summary>
/// <param name="GROUP_ID"></param>
/// <returns></returns>
public bool Load(long GROUP_ID)
{
using (SGGSEntities context = new SGGSEntities())
{
var result = (from g in context.SGGS_GROUP
where g.GROUP_ID == GROUP_ID
select new
{
g.DATE_ADDED,
g.DATE_UPDATED,
g.DEFAULT_PUBLISHER_NUMBER,
g.GROUP_CODE,
g.GROUP_DESCRIPTION,
g.GROUP_ID,
g.GROUP_NAME
}).FirstOrDefault();
if (result != null)
{
this.DATE_ADDED = result.DATE_ADDED.Value;
this.DATE_UPDATED = result.DATE_UPDATED.Value;
this.DEFAULT_PUBLISHER_NUMBER = result.DEFAULT_PUBLISHER_NUMBER;
this.GROUP_CODE = result.GROUP_CODE;
this.GROUP_DESCRIPTION = result.GROUP_DESCRIPTION;
this.GROUP_ID = result.GROUP_ID;
this.GROUP_NAME = result.GROUP_NAME;
return(true);
}
return(false);
}
}
/// <summary>
/// Method that adds new trim format to the duplicated print plant profile
/// </summary>
/// <returns></returns>
public bool AddDuplicatedTrimFormats()
{
using (var context = new SGGSEntities())
{
var trimFormat = new SGGS_SUPPORTED_TRIM_FORMATS
{
SUPPORTED_PAPER_TYPE_ID = SUPPORTED_PAPER_TYPE,
SUPPORTED_BIND_TYPE_ID = SUPPORTED_BINDING_TYPE,
PRINT_PLANT_PROFILE_ID = PRINT_PLANT_PROFILE_ID,
TRIM_FORMAT_ID = TRIM_FORMAT_ID,
TEXT_PAGE_COUNT_MAX = MAX_PAGES,
TEXT_PAGE_COUNT_MIN = MIN_PAGES,
TRIM_FORMAT_MIN_WIDTH = TRIM_FORMAT_MIN_WIDTH,
TRIM_FORMAT_MAX_WIDTH = TRIM_FORMAT_MAX_WIDTH,
TRIM_FORMAT_MAX_HEIGHT = TRIM_FORMAT_MAX_HEIGHT,
TRIM_FORMAT_MIN_HEIGHT = TRIM_FORMAT_MIN_HEIGHT,
OVERRIDE_AUTO_CALCULATION = OVERRIDE_AUTO_CALCULATION,
SUPPORTED_PRINT_QUALITY = SUPPORTED_PRINT_QUALITY_ID
};
context.SGGS_SUPPORTED_TRIM_FORMATS.AddObject(trimFormat);
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Get Supported TrimFormat Information
/// </summary>
/// <param name="trimFormatId"></param>
/// <returns></returns>
public dynamic GetSupportedTrimFormatInformation(long trimFormatId)
{
using (var context = new SGGSEntities())
{
var trimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS.AsEnumerable()
.Where(x => x.SUPPORTED_TRIM_FORMATS_ID == trimFormatId)
.Select(s => new
{
TRIM_FORMAT_ID = s.SUPPORTED_TRIM_FORMATS_ID,
PAPER_TYPE = (from p in context.SGGS_PAPER_TYPE
join sp in context.SGGS_SUPPORTED_PAPER_TYPE on p.PAPER_TYPE_ID equals sp.PAPER_TYPE_ID
where sp.SUPPORTED_PAPER_TYPE_ID == s.SUPPORTED_PAPER_TYPE_ID
select p.PAPER_NAME).FirstOrDefault(),
BINDING_TYPE = (from b in context.SGGS_CODE_BINDING_TYPE
join sb in context.SGGS_SUPPORTED_BIND_TYPE on b.BINDING_TYPE_ID equals sb.BINDING_TYPE_ID
where sb.SUPPORTED_BIND_TYPE_ID == s.SUPPORTED_BIND_TYPE_ID
select b.BINDING_TYPE_NAME).FirstOrDefault(),
TRIM_FORMAT = context.SGGS_CODE_TRIM_FORMAT.Where(t => t.TRIM_FORMAT_ID == s.TRIM_FORMAT_ID).Select(ts => ts.TRIM_FORMAT_NAME).FirstOrDefault(),
PRINT_QUALITY = context.SGGS_CODE_PRINT_QUALITY.Where(q => q.PRINT_QUALITY_ID == s.SUPPORTED_PRINT_QUALITY).Select(qs => qs.PRINT_QUALITY_NAME).FirstOrDefault(),
MIN_PAGES = s.TEXT_PAGE_COUNT_MIN,
MAX_PAGES = s.TEXT_PAGE_COUNT_MAX,
WIDTH = (s.TRIM_FORMAT_MIN_WIDTH.HasValue ? s.TRIM_FORMAT_MIN_WIDTH.Value.ToString("G29"):"") + " - " + (s.TRIM_FORMAT_MAX_WIDTH.HasValue ? s.TRIM_FORMAT_MAX_WIDTH.Value.ToString("G29"):""),
HEIGHT = (s.TRIM_FORMAT_MIN_HEIGHT.HasValue ? s.TRIM_FORMAT_MIN_HEIGHT.Value.ToString("G29"):"") + " - " + (s.TRIM_FORMAT_MAX_HEIGHT.HasValue? s.TRIM_FORMAT_MAX_HEIGHT.Value.ToString("G29"):""),
OVERRIDE = s.OVERRIDE_AUTO_CALCULATION
}).FirstOrDefault();
return(trimFormats);
}
}
/// <summary>
/// Add a new pubisher group
/// </summary>
/// <param name="groupID"></param>
/// <param name="PUBLISHER_ID"></param>
/// <returns></returns>
public bool AddGroupPublishers(long groupID, long PUBLISHER_ID)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
var group = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == groupID && x.PUBLISHER_ID == PUBLISHER_ID).FirstOrDefault();
if (group == null)
{
SGGS_GROUP_PUBLISHER newGroup = new SGGS_GROUP_PUBLISHER();
newGroup.PUBLISHER_ID = PUBLISHER_ID;
newGroup.GROUP_ID = groupID;
newGroup.DATE_ADDED = DateTime.Now;
newGroup.DATE_UPDATED = DateTime.Now;
context.SGGS_GROUP_PUBLISHER.AddObject(newGroup);
context.SaveChanges();
return(true);
}
return(false);
}
}
catch
{
return(false);
}
}
/// <summary>
/// Get Publisher group by group Id
/// </summary>
/// <param name="GROUP_ID"></param>
/// <returns></returns>
public DataTable GetGroupPublishers(long GROUP_ID)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
List <string> publisherIds = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == GROUP_ID).Select(s => s.PUBLISHER_ID.ToString()).ToList();
var result = (from p in context.SGGS_PUBLISHER
where publisherIds.Contains(p.PUBLISHER_ID.ToString())
select p).AsEnumerable()
.Select(s => new
{
s.PUBLISHER_ID,
PUBLISHER_NAME = s.PUBLISHER_NUMBER + "-" + s.PUBLISHER_NAME
}).ToList();
return(CommonUtils.ToDataTable(result));
}
}
catch
{
return(null);
}
}
/// <summary>
/// Method to Delete Record by SuptrimformatID
/// </summary>
/// <param name="suppTrimFormatID"></param>
/// <returns></returns>
public bool DeleteSupportTrimFormat(long suppTrimFormatID)
{
using (var context = new SGGSEntities())
{
var suppTrim = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == suppTrimFormatID);
context.SGGS_SUPPORTED_TRIM_FORMATS.DeleteObject(suppTrim);
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Method to Delete Record
/// </summary>
/// <returns></returns>
public bool Delete()
{
using (var context = new SGGSEntities())
{
var trim = context.SGGS_CODE_TRIM_FORMAT.FirstOrDefault(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID);
context.SGGS_CODE_TRIM_FORMAT.DeleteObject(trim);
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Method to Delete Record
/// </summary>
/// <returns></returns>
public Boolean Delete()
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == GROUP_ID).FirstOrDefault();
context.SGGS_GROUP.DeleteObject(group);
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Static method to get GroupCode for a specified groupID
/// </summary>
/// <param name="db"></param>
/// <param name="groupCode"></param>
/// <returns></returns>
public static string GetGroupCode(long groupID)
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP publisher = context.SGGS_GROUP.Where(x => x.GROUP_ID == groupID).FirstOrDefault();
if (publisher != null)
{
return(publisher.GROUP_CODE);
}
return(string.Empty);
}
}
/// <summary>
/// Method to update a record
/// </summary>
/// <returns></returns>
public Boolean Save()
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == GROUP_ID).FirstOrDefault();
group.DATE_UPDATED = DateTime.Now;
group.DEFAULT_PUBLISHER_NUMBER = DEFAULT_PUBLISHER_NUMBER;
group.GROUP_CODE = GROUP_CODE;
group.GROUP_DESCRIPTION = GROUP_DESCRIPTION;
group.GROUP_NAME = GROUP_NAME;
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Add Duplicate Supported TrimFormat
/// </summary>
/// <param name="oldPrintPlantProfileId"></param>
/// <param name="newPrintPlantProfile"></param>
public void DuplicateSupportedTrimFormat(long oldPrintPlantProfileId, long newPrintPlantProfile)
{
using (var context = new SGGSEntities())
{
var supportedTrimFormats = (from tf in context.SGGS_SUPPORTED_TRIM_FORMATS
join pt in context.SGGS_SUPPORTED_PAPER_TYPE on tf.SUPPORTED_PAPER_TYPE_ID equals pt.SUPPORTED_PAPER_TYPE_ID
join bt in context.SGGS_SUPPORTED_BIND_TYPE on tf.SUPPORTED_BIND_TYPE_ID equals bt.SUPPORTED_BIND_TYPE_ID
where tf.PRINT_PLANT_PROFILE_ID == oldPrintPlantProfileId
select new TrimFormat
{
SUPPORTED_PAPER_TYPE = tf.SUPPORTED_PAPER_TYPE_ID,
SUPPORTED_BINDING_TYPE = tf.SUPPORTED_BIND_TYPE_ID,
PAPER_TYPE_ID = pt.PAPER_TYPE_ID,
BINDING_TYPE_ID = bt.BINDING_TYPE_ID,
PRINT_PLANT_PROFILE_ID = tf.PRINT_PLANT_PROFILE_ID,
TRIM_FORMAT_ID = tf.TRIM_FORMAT_ID,
MAX_PAGES = tf.TEXT_PAGE_COUNT_MAX,
MIN_PAGES = tf.TEXT_PAGE_COUNT_MIN,
TRIM_FORMAT_MIN_WIDTH = tf.TRIM_FORMAT_MIN_WIDTH,
TRIM_FORMAT_MAX_WIDTH = tf.TRIM_FORMAT_MAX_WIDTH,
TRIM_FORMAT_MAX_HEIGHT = tf.TRIM_FORMAT_MAX_HEIGHT,
TRIM_FORMAT_MIN_HEIGHT = tf.TRIM_FORMAT_MIN_HEIGHT,
OVERRIDE_AUTO_CALCULATION = tf.OVERRIDE_AUTO_CALCULATION,
SUPPORTED_PRINT_QUALITY_ID = tf.SUPPORTED_PRINT_QUALITY
}).ToList();
foreach (var item in supportedTrimFormats)
{
SUPPORTED_PAPER_TYPE = (from bt in context.SGGS_SUPPORTED_PAPER_TYPE
where bt.PRINT_PLANT_PROFILE_ID == newPrintPlantProfile && bt.PAPER_TYPE_ID == item.PAPER_TYPE_ID
select bt.SUPPORTED_PAPER_TYPE_ID).FirstOrDefault();
SUPPORTED_BINDING_TYPE = (from bt in context.SGGS_SUPPORTED_BIND_TYPE
where bt.PRINT_PLANT_PROFILE_ID == newPrintPlantProfile && bt.BINDING_TYPE_ID == item.BINDING_TYPE_ID
select bt.SUPPORTED_BIND_TYPE_ID).FirstOrDefault();
PRINT_PLANT_PROFILE_ID = newPrintPlantProfile;
TRIM_FORMAT_ID = item.TRIM_FORMAT_ID;
MAX_PAGES = item.MAX_PAGES;
MIN_PAGES = item.MIN_PAGES;
TRIM_FORMAT_MIN_WIDTH = item.TRIM_FORMAT_MIN_WIDTH;
TRIM_FORMAT_MAX_WIDTH = item.TRIM_FORMAT_MAX_WIDTH;
TRIM_FORMAT_MAX_HEIGHT = item.TRIM_FORMAT_MAX_HEIGHT;
TRIM_FORMAT_MIN_HEIGHT = item.TRIM_FORMAT_MIN_HEIGHT;
OVERRIDE_AUTO_CALCULATION = item.OVERRIDE_AUTO_CALCULATION;
SUPPORTED_PRINT_QUALITY_ID = item.SUPPORTED_PRINT_QUALITY_ID;
AddDuplicatedTrimFormats();
}
}
}
/// <summary>
/// Remove a TrimFormat by trimFormatId
/// </summary>
/// <param name="trimFormatId"></param>
/// <returns></returns>
public string RemoveTrimFormat(long trimFormatId)
{
using (var context = new SGGSEntities())
{
var trimFormat = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == trimFormatId);
if (trimFormat == null)
{
return("notRemoved");
}
context.SGGS_SUPPORTED_TRIM_FORMATS.DeleteObject(trimFormat);
context.SaveChanges();
return("removed");
}
}
/// <summary>
/// Update a group publisher
/// </summary>
/// <param name="publisherNumber"></param>
/// <param name="billToPublisherNumber"></param>
/// <returns></returns>
public bool UpdateGroupPublishers(string publisherNumber, string billToPublisherNumber)
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == this.GROUP_ID).FirstOrDefault();
if (group != null)
{
group.DEFAULT_PUBLISHER_NUMBER = publisherNumber;
group.DEFAULT_BILL_TO_PUBLISHER_NUMBER = billToPublisherNumber;
context.SaveChanges();
return(true);
}
return(false);
}
}
/// <summary>
/// To delete data that was duplicated
/// </summary>
/// <param name="printPlantProfileId">print plant profile identifier</param>
public void DeleteDuplicatedSupportedTrimFormat(long printPlantProfileId)
{
using (var context = new SGGSEntities())
{
var supportedTrimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS
.Where(x => x.PRINT_PLANT_PROFILE_ID == printPlantProfileId)
.Select(s => new
{
s.SUPPORTED_TRIM_FORMATS_ID
}).ToList();
foreach (var item in supportedTrimFormats)
{
DeleteSupportTrimFormat(item.SUPPORTED_TRIM_FORMATS_ID);
}
}
}
/// <summary>
/// Method to insert record in Group Table
/// </summary>
/// <returns></returns>
public Boolean Add()
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP group = new SGGS_GROUP();
group.DATE_ADDED = DateTime.Now;
group.DATE_UPDATED = DateTime.Now;
group.DEFAULT_PUBLISHER_NUMBER = DEFAULT_PUBLISHER_NUMBER;
group.GROUP_CODE = GROUP_CODE;
group.GROUP_DESCRIPTION = GROUP_DESCRIPTION;
group.GROUP_NAME = GROUP_NAME;
context.SGGS_GROUP.AddObject(group);
context.SaveChanges();
GROUP_ID = group.GROUP_ID;
return(true);
}
}
/// <summary>
/// Delete a publisher group
/// </summary>
/// <param name="groupID"></param>
/// <param name="publisherID"></param>
/// <returns></returns>
public bool DeleteGroupPublisher(long groupID, long publisherID)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
SGGS_GROUP_PUBLISHER group = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == groupID && x.PUBLISHER_ID == publisherID).FirstOrDefault();
context.SGGS_GROUP_PUBLISHER.DeleteObject(group);
context.SaveChanges();
return(true);
}
}
catch
{
return(false);
}
}
/// <summary>
/// Get All groups by search criteria
/// </summary>
/// <param name="search"></param>
/// <returns></returns>
public DataTable GetAllGroups(string search)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
if (!string.IsNullOrEmpty(search))
{
var result = context.SGGS_GROUP.Where(x => x.GROUP_CODE.ToString().Contains(search) || x.GROUP_NAME.Contains(search) || x.DEFAULT_PUBLISHER_NUMBER.Contains(search))
.OrderBy(o => o.GROUP_CODE)
.Select(s => new
{
s.DATE_ADDED,
s.DATE_UPDATED,
DEFAULT_PUBLISHER_NUMBER = context.SGGS_PUBLISHER.Where(x => x.PUBLISHER_NUMBER == s.DEFAULT_PUBLISHER_NUMBER).Select(n => new { Name = n.PUBLISHER_NUMBER + "-" + n.PUBLISHER_NAME }).FirstOrDefault().Name,
s.GROUP_CODE,
s.GROUP_DESCRIPTION,
s.GROUP_ID,
s.GROUP_NAME
}).ToList();
return(CommonUtils.ToDataTable(result));
}
else
{
var result = context.SGGS_GROUP.OrderBy(o => o.GROUP_CODE)
.Select(s => new
{
s.DATE_ADDED,
s.DATE_UPDATED,
DEFAULT_PUBLISHER_NUMBER = context.SGGS_PUBLISHER.Where(x => x.PUBLISHER_NUMBER == s.DEFAULT_PUBLISHER_NUMBER).Select(n => new { Name = n.PUBLISHER_NUMBER + "-" + n.PUBLISHER_NAME }).FirstOrDefault().Name,
s.GROUP_CODE,
s.GROUP_DESCRIPTION,
s.GROUP_ID,
s.GROUP_NAME
}).ToList();
return(CommonUtils.ToDataTable(result));
}
}
}
catch
{
return(null);
}
}
/// <summary>
/// Method to Load values from DB
/// </summary>
/// <param name="TRIM_FORMAT_ID"></param>
/// <returns></returns>
public bool Load(long TRIM_FORMAT_ID)
{
using (var context = new SGGSEntities())
{
var result = context.SGGS_CODE_TRIM_FORMAT.Where(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID)
.Select(s => new
{
s.DATE_ADDED,
s.DATE_UPDATED,
s.TRIM_FORMAT_HEIGHT_IN,
s.TRIM_FORMAT_HEIGHT_MM,
s.TRIM_FORMAT_ID,
s.TRIM_FORMAT_NAME,
s.TRIM_FORMAT_NUMBER,
s.TRIM_FORMAT_WIDTH_IN,
s.TRIM_FORMAT_WIDTH_MM,
s.USAGE_HARDCOVER,
s.USAGE_PAPERBACK,
s.HARD_COVER,
s.SOFT_COVER
}).FirstOrDefault();
if (result != null)
{
this.DATE_ADDED = result.DATE_ADDED;
this.DATE_UPDATED = result.DATE_UPDATED.Value;
this.TRIM_FORMAT_HEIGHT_IN = result.TRIM_FORMAT_HEIGHT_IN;
this.TRIM_FORMAT_HEIGHT_MM = result.TRIM_FORMAT_HEIGHT_MM;
this.TRIM_FORMAT_ID = result.TRIM_FORMAT_ID;
this.TRIM_FORMAT_NAME = result.TRIM_FORMAT_NAME;
this.TRIM_FORMAT_NUMBER = result.TRIM_FORMAT_NUMBER;
this.TRIM_FORMAT_WIDTH_IN = result.TRIM_FORMAT_WIDTH_IN;
this.TRIM_FORMAT_WIDTH_MM = result.TRIM_FORMAT_WIDTH_MM;
this.USAGE_HARDCOVER = result.USAGE_HARDCOVER;
this.USAGE_PAPERBACK = result.USAGE_PAPERBACK;
this.HARD_COVER = result.HARD_COVER ?? false;
this.SOFT_COVER = result.SOFT_COVER ?? false;
return(true);
}
return(false);
}
}
/// <summary>
/// Method to insert record
/// </summary>
/// <returns></returns>
public bool Save()
{
using (var context = new SGGSEntities())
{
var trim = context.SGGS_CODE_TRIM_FORMAT.FirstOrDefault(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID);
trim.DATE_UPDATED = DateTime.Now;
trim.TRIM_FORMAT_HEIGHT_IN = TRIM_FORMAT_HEIGHT_IN;
trim.TRIM_FORMAT_HEIGHT_MM = TRIM_FORMAT_HEIGHT_MM;
trim.TRIM_FORMAT_NAME = TRIM_FORMAT_NAME;
trim.TRIM_FORMAT_NUMBER = TRIM_FORMAT_NUMBER;
trim.TRIM_FORMAT_WIDTH_IN = TRIM_FORMAT_WIDTH_IN;
trim.TRIM_FORMAT_WIDTH_MM = TRIM_FORMAT_WIDTH_MM;
trim.USAGE_HARDCOVER = USAGE_HARDCOVER;
trim.USAGE_PAPERBACK = USAGE_PAPERBACK;
trim.SOFT_COVER = SOFT_COVER;
trim.HARD_COVER = HARD_COVER;
context.SaveChanges();
return(true);
}
}
/// <summary>
/// GetGroupName: return group name using Group Code
/// </summary>
/// <param name="db"></param>
/// <param name="groupCode"></param>
/// <returns></returns>
public static string GetGroupNameUsingGroupCode(string groupCode)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
var result = context.SGGS_GROUP.Where(x => x.GROUP_CODE == groupCode).Select(s => new { s.GROUP_NAME }).FirstOrDefault();
if (result != null)
{
return(result.GROUP_NAME);
}
return("None");
}
}
catch
{
return("None");
}
}
/// <summary>
/// Get Group Default Bill To Publisher
/// </summary>
/// <param name="groupID"></param>
/// <returns></returns>
public static string GetGroupDefaultBillToPublisher(long groupID)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
var result = context.SGGS_GROUP.Where(x => x.GROUP_ID == groupID).Select(s => new { s.DEFAULT_BILL_TO_PUBLISHER_NUMBER }).FirstOrDefault();
if (result != null)
{
return(result.DEFAULT_BILL_TO_PUBLISHER_NUMBER);
}
return(string.Empty);
}
}
catch
{
return(string.Empty);
}
}
/// <summary>
/// Get Paper Type and Print Quality Information
/// </summary>
/// <param name="suppPaperTypeID"></param>
/// <param name="PrintQualityID"></param>
/// <returns></returns>
public dynamic GetPaperQualityInformation(long suppPaperTypeID, long PrintQualityID)
{
using (var context = new SGGSEntities())
{
var paperQualityInformation = context.SGGS_SUPPORTED_PAPER_TYPE
.Where(x => x.SUPPORTED_PAPER_TYPE_ID == suppPaperTypeID)
.Select(s => new
{
PAPER_TYPE_NAME = (from p in context.SGGS_PAPER_TYPE
where p.PAPER_TYPE_ID == s.PAPER_TYPE_ID
select p.PAPER_NAME).FirstOrDefault(),
PrintQuality = (from pq in context.SGGS_CODE_PRINT_QUALITY
where pq.PRINT_QUALITY_ID == PrintQualityID
select pq.PRINT_QUALITY_NAME).FirstOrDefault(),
}).FirstOrDefault();
return(paperQualityInformation != null ? paperQualityInformation : null);
}
}
/// <summary>
/// Method that adds new trim format to the print plant profile
/// </summary>
/// <param name="formats">New trim formats added</param>
/// <returns></returns>
public bool AddSupportedTrimFormats(IList <TrimFormat> formats, bool supportRanges)
{
if (formats.Count <= 0)
{
return(false);
}
using (var context = new SGGSEntities())
{
foreach (var item in formats)
{
var sggsCodePrintQuality = context.SGGS_CODE_PRINT_QUALITY.FirstOrDefault(q => q.PRINT_QUALITY_NUMBER == item.SUPPORTED_PRINT_QUALITY);
var trimFormat = new SGGS_SUPPORTED_TRIM_FORMATS
{
SUPPORTED_PAPER_TYPE_ID = item.SUPPORTED_PAPER_TYPE,
SUPPORTED_BIND_TYPE_ID = item.SUPPORTED_BINDING_TYPE,
PRINT_PLANT_PROFILE_ID = item.PRINT_PLANT_PROFILE_ID,
TRIM_FORMAT_ID = item.TRIM_FORMAT_ID,
TEXT_PAGE_COUNT_MAX = item.MAX_PAGES,
TEXT_PAGE_COUNT_MIN = item.MIN_PAGES,
TRIM_FORMAT_MAX_HEIGHT = item.TRIM_FORMAT_MAX_HEIGHT,
TRIM_FORMAT_MIN_HEIGHT = item.TRIM_FORMAT_MIN_HEIGHT,
TRIM_FORMAT_MIN_WIDTH = item.TRIM_FORMAT_MIN_WIDTH,
TRIM_FORMAT_MAX_WIDTH = item.TRIM_FORMAT_MAX_WIDTH,
OVERRIDE_AUTO_CALCULATION = item.OVERRIDE_AUTO_CALCULATION
};
if (sggsCodePrintQuality != null)
{
trimFormat.SUPPORTED_PRINT_QUALITY = sggsCodePrintQuality.PRINT_QUALITY_ID;
}
if (!CheckTrimFormatIsValid(trimFormat, supportRanges))
{
context.SGGS_SUPPORTED_TRIM_FORMATS.AddObject(trimFormat);
}
}
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Method to Delete Record by SuptrimformatID
/// </summary>
/// <returns></returns>
public DataTable GetTrimFormat()
{
using (var context = new SGGSEntities())
{
var result = context.SGGS_CODE_TRIM_FORMAT
.Select(s => new
{
s.TRIM_FORMAT_ID,
s.TRIM_FORMAT_NAME,
s.TRIM_FORMAT_NUMBER,
s.TRIM_FORMAT_WIDTH_MM,
s.TRIM_FORMAT_WIDTH_IN,
s.TRIM_FORMAT_HEIGHT_MM,
s.TRIM_FORMAT_HEIGHT_IN,
USAGE_PAPERBACK = s.USAGE_PAPERBACK == true ? "Yes" : "No",
USAGE_HARDCOVER = s.USAGE_HARDCOVER == true ? "Yes" : "No"
}).ToList();
return(CommonUtils.ToDataTable(result, "TrimFormat"));
}
}
/// <summary>
/// Get Trim format by printPlantProfileId
/// </summary>
/// <param name="printPlantProfileId"></param>
/// <returns></returns>
public DataTable GetTrimFormat(long printPlantProfileId)
{
using (var context = new SGGSEntities())
{
var profile = (from ppp in context.SGGS_PRINT_PLANT_PROFILE
where ppp.PRINT_PLANT_PROFILE_ID == printPlantProfileId
select ppp).FirstOrDefault();
if (profile != null)
{
if (profile.COVER_TYPE.ToUpper().Equals("S"))
{
var result = context.SGGS_CODE_TRIM_FORMAT
.Where(x => x.SOFT_COVER == true)
.Select(s => new
{
s.TRIM_FORMAT_ID,
TRIM_FORMAT_NAME = s.TRIM_FORMAT_NAME + " (" + ((double)s.TRIM_FORMAT_WIDTH_IN).ToString() + " x " + ((double)s.TRIM_FORMAT_HEIGHT_IN).ToString() + ")"
}).OrderBy(tf => tf.TRIM_FORMAT_NAME).ToList();
return(CommonUtils.ToDataTable(result, "TrimFormat"));
}
if (profile.COVER_TYPE.ToUpper().Equals("H"))
{
var result = context.SGGS_CODE_TRIM_FORMAT
.Where(x => x.HARD_COVER == true)
.Select(s => new
{
s.TRIM_FORMAT_ID,
TRIM_FORMAT_NAME = s.TRIM_FORMAT_NAME + " (" + ((double)s.TRIM_FORMAT_WIDTH_IN).ToString() + " x " + ((double)s.TRIM_FORMAT_HEIGHT_IN).ToString() + ")"
}).OrderBy(tf => tf.TRIM_FORMAT_NAME).ToList();
return(CommonUtils.ToDataTable(result, "TrimFormat"));
}
return(null);
}
return(null);
}
}
/// <summary>
/// Inserts or update a new book into sggs
/// </summary>
/// <param name="publisherNumber"></param>
/// <param name="title"></param>
/// <param name="subtitle"></param>
/// <param name="isbn"></param>
/// <param name="edition"></param>
/// <param name="copyRightYear"></param>
/// <returns></returns>
public SGGS_BOOK InsertUpdateBook(string publisherNumber, string title, string subtitle, string isbn, string edition, string copyRightYear)
{
using (SGGSEntities objSGGS = new SGGSEntities())
{
SGGS_BOOK sggsBook = new SGGS_BOOK();
SGGS_PUBLISHER sggsPublisher = new SGGS_PUBLISHER();
var publisher = objSGGS.SGGS_PUBLISHER.Where(P => P.PUBLISHER_NUMBER == publisherNumber).FirstOrDefault(); ///////
if (publisher != null)
{
sggsBook = (from B in objSGGS.SGGS_BOOK
where B.BOOK_NUMBER == isbn && B.PUBLISHER_ID == publisher.PUBLISHER_ID
select B).SingleOrDefault();
if (sggsBook == null)
{
sggsBook = new SGGS_BOOK();
sggsBook.BOOK_TITLE = title;
sggsBook.DATE_UPDATED = System.DateTime.Now;
sggsBook.PUBLISHER_ID = publisher.PUBLISHER_ID;
sggsBook.BOOK_IDENTIFICATION_TYPE = "ISBN";
sggsBook.BOOK_NUMBER = isbn;
sggsBook.IS_ENABLED = true;
sggsBook.IS_NEW = true;
sggsBook.DATE_ADDED = System.DateTime.Now;
objSGGS.SGGS_BOOK.AddObject(sggsBook);
objSGGS.SaveChanges();
}
else if (sggsBook != null)
{
sggsBook.BOOK_TITLE = title;
sggsBook.DATE_UPDATED = System.DateTime.Now;
objSGGS.SaveChanges();
}
}
return(sggsBook);
}
}
/// <summary>
/// Edit Publisher group by Group ID
/// </summary>
/// <param name="GROUP_ID"></param>
/// <returns></returns>
public DataTable EditGroupPublishers(long GROUP_ID)
{
try
{
using (SGGSEntities context = new SGGSEntities())
{
var result = (from p in context.SGGS_PUBLISHER
select p).AsEnumerable()
.Select(s => new
{
s.PUBLISHER_ID,
PUBLISHER_NAME = s.PUBLISHER_NUMBER + "-" + s.PUBLISHER_NAME,
s.PUBLISHER_NUMBER,
IS_GROUP_PUBLISHER = context.SGGS_GROUP_PUBLISHER.Any(gp => gp.GROUP_ID == GROUP_ID && gp.PUBLISHER_ID == s.PUBLISHER_ID)
}).OrderBy(o => o.PUBLISHER_NUMBER).ToList();
return(CommonUtils.ToDataTable(result));
}
}
catch
{
return(null);
}
}
/// <summary>
/// Update TrimFormat Update
/// </summary>
/// <param name="supportedTrimFormatId"></param>
/// <param name="minPages"></param>
/// <param name="maxPages"></param>
/// <param name="minWidth"></param>
/// <param name="maxWidth"></param>
/// <param name="minHeight"></param>
/// <param name="maxHeight"></param>
/// <param name="overriding"></param>
/// <returns></returns>
public string Update(long supportedTrimFormatId, int?minPages, int?maxPages, decimal?minWidth, decimal?maxWidth,
decimal?minHeight, decimal?maxHeight, bool overriding)
{
using (var context = new SGGSEntities())
{
var trimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == supportedTrimFormatId);
if (trimFormats == null)
{
return("notSaved");
}
trimFormats.TEXT_PAGE_COUNT_MIN = minPages;
trimFormats.TEXT_PAGE_COUNT_MAX = maxPages;
trimFormats.TRIM_FORMAT_MIN_WIDTH = minWidth;
trimFormats.TRIM_FORMAT_MAX_WIDTH = maxWidth;
trimFormats.TRIM_FORMAT_MIN_HEIGHT = minHeight;
trimFormats.TRIM_FORMAT_MAX_HEIGHT = maxHeight;
trimFormats.OVERRIDE_AUTO_CALCULATION = overriding;
context.SaveChanges();
return("saved");
}
}
/// <summary>
/// Update TrimFormat
/// </summary>
/// <param name="supportedTrimFormatId"></param>
/// <param name="minPages"></param>
/// <param name="maxPages"></param>
/// <param name="minWidth"></param>
/// <param name="maxWidth"></param>
/// <param name="minHeight"></param>
/// <param name="maxHeight"></param>
/// <param name="overriding"></param>
/// <param name="supportRanges"></param>
/// <returns></returns>
public string UpdatingTrimFormat(long supportedTrimFormatId, string minPages, string maxPages, string minWidth, string maxWidth,
string minHeight, string maxHeight, bool overriding, bool supportRanges)
{
using (var context = new SGGSEntities())
{
SGGS_SUPPORTED_TRIM_FORMATS dataFound = null;
var trimFormat = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == supportedTrimFormatId);
if (trimFormat == null)
{
return("notExists");
}
if (!supportRanges && overriding)
{
var maxP = Convert.ToInt32(maxPages);
var minP = Convert.ToInt32(minPages);
dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf =>
tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID &&
tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID &&
tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID &&
tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID &&
tf.TRIM_FORMAT_ID == trimFormat.TRIM_FORMAT_ID &&
tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY &&
tf.TEXT_PAGE_COUNT_MAX == maxP &&
tf.TEXT_PAGE_COUNT_MIN == minP &&
tf.TRIM_FORMAT_MIN_WIDTH == null &&
tf.TRIM_FORMAT_MAX_WIDTH == null &&
tf.TRIM_FORMAT_MIN_HEIGHT == null &&
tf.TRIM_FORMAT_MAX_HEIGHT == null &&
tf.OVERRIDE_AUTO_CALCULATION == overriding);
if (dataFound == null)
{
return(Update(supportedTrimFormatId, Convert.ToInt32(minPages), Convert.ToInt32(maxPages), null, null, null, null, overriding));
}
}
else if (!supportRanges && !overriding)
{
dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf =>
tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID &&
tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID &&
tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID &&
tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID &&
tf.TRIM_FORMAT_ID == trimFormat.TRIM_FORMAT_ID &&
tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY &&
tf.TEXT_PAGE_COUNT_MAX == null &&
tf.TEXT_PAGE_COUNT_MIN == null &&
tf.TRIM_FORMAT_MIN_WIDTH == null &&
tf.TRIM_FORMAT_MAX_WIDTH == null &&
tf.TRIM_FORMAT_MIN_HEIGHT == null &&
tf.TRIM_FORMAT_MAX_HEIGHT == null &&
tf.OVERRIDE_AUTO_CALCULATION == overriding);
if (dataFound == null)
{
return(Update(supportedTrimFormatId, null, null, null, null, null, null, overriding));
}
}
else if (supportRanges && !overriding)
{
var maxW = Math.Round(Convert.ToDecimal(maxWidth), 5);
var minW = Math.Round(Convert.ToDecimal(minWidth), 5);
var minH = Math.Round(Convert.ToDecimal(minHeight), 5);
var maxH = Math.Round(Convert.ToDecimal(maxHeight), 5);
dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf =>
tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID &&
tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID &&
tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID &&
tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID &&
tf.TRIM_FORMAT_ID == null &&
tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY &&
tf.TEXT_PAGE_COUNT_MAX == null &&
tf.TEXT_PAGE_COUNT_MIN == null &&
tf.TRIM_FORMAT_MIN_WIDTH == minW &&
tf.TRIM_FORMAT_MAX_WIDTH == maxW &&
tf.TRIM_FORMAT_MIN_HEIGHT == minH &&
tf.TRIM_FORMAT_MAX_HEIGHT == maxH &&
tf.OVERRIDE_AUTO_CALCULATION == overriding);
if (dataFound == null)
{
return(Update(supportedTrimFormatId, null, null, Math.Round(Convert.ToDecimal(minWidth), 5), Math.Round(Convert.ToDecimal(maxWidth), 5), Math.Round(Convert.ToDecimal(minHeight), 5),
Math.Round(Convert.ToDecimal(maxHeight), 5), overriding));
}
}
return(dataFound != null ? "exists" : string.Empty);
}
}
