public long UpdateStructure(StructureObject structure)
{
try
{
if (structure == null)
{
return(-2);
}
var structureEntity = ModelMapper.Map <StructureObject, Structure>(structure);
if (structureEntity == null || structureEntity.StructureId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Structures.Attach(structureEntity);
db.Entry(structureEntity).State = EntityState.Modified;
db.SaveChanges();
return(structure.StructureId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public List <AccountTypeObject> GetAccountTypes()
{
try
{
using (var db = new ImportPermitEntities())
{
var accountTypes = db.AccountTypes.ToList();
if (!accountTypes.Any())
{
return(new List <AccountTypeObject>());
}
var objList = new List <AccountTypeObject>();
accountTypes.ForEach(app =>
{
var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app);
if (accountTypeObject != null && accountTypeObject.AccountTypeId > 0)
{
objList.Add(accountTypeObject);
}
});
return(!objList.Any() ? new List <AccountTypeObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public ProductColumnObject GetProductColumn(long productColumnId)
{
try
{
using (var db = new ImportPermitEntities())
{
var productColumns =
db.ProductColumns.Where(m => m.ProductColumnId == productColumnId)
.Include("CustomCode")
.Include("Product")
.ToList();
if (!productColumns.Any())
{
return(new ProductColumnObject());
}
var app = productColumns[0];
var productColumnObject = ModelMapper.Map <ProductColumn, ProductColumnObject>(app);
if (productColumnObject == null || productColumnObject.ProductColumnId < 1)
{
return(new ProductColumnObject());
}
productColumnObject.ProductName = app.Product.Name;
productColumnObject.CustomCodeName = app.CustomCode.Name;
return(productColumnObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new ProductColumnObject());
}
}
public AccountTypeObject GetAccountType(long accountTypeId)
{
try
{
using (var db = new ImportPermitEntities())
{
var accountTypes =
db.AccountTypes.Where(m => m.AccountTypeId == accountTypeId)
.ToList();
if (!accountTypes.Any())
{
return(new AccountTypeObject());
}
var app = accountTypes[0];
var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app);
if (accountTypeObject == null || accountTypeObject.AccountTypeId < 1)
{
return(new AccountTypeObject());
}
return(accountTypeObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new AccountTypeObject());
}
}
public List <AccountTypeObject> Search(string searchCriteria)
{
try
{
using (var db = new ImportPermitEntities())
{
var accountTypes =
db.AccountTypes.Where(m => m.Name.ToLower().Trim() == searchCriteria.ToLower().Trim())
.ToList();
if (accountTypes.Any())
{
var newList = new List <AccountTypeObject>();
accountTypes.ForEach(app =>
{
var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app);
if (accountTypeObject != null && accountTypeObject.AccountTypeId > 0)
{
newList.Add(accountTypeObject);
}
});
return(newList);
}
}
return(new List <AccountTypeObject>());
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new List <AccountTypeObject>());
}
}
public CustomCodeObject GetCustomCode(long customCodeId)
{
try
{
using (var db = new ImportPermitEntities())
{
var customCodes =
db.CustomCodes.Where(m => m.CustomCodeId == customCodeId)
.ToList();
if (!customCodes.Any())
{
return(new CustomCodeObject());
}
var app = customCodes[0];
var customCodeObject = ModelMapper.Map <CustomCode, CustomCodeObject>(app);
if (customCodeObject == null || customCodeObject.CustomCodeId < 1)
{
return(new CustomCodeObject());
}
return(customCodeObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new CustomCodeObject());
}
}
public List <CustomCodeObject> GetCustomCodes()
{
try
{
using (var db = new ImportPermitEntities())
{
var customCodes = db.CustomCodes.ToList();
if (!customCodes.Any())
{
return(new List <CustomCodeObject>());
}
var objList = new List <CustomCodeObject>();
customCodes.ForEach(app =>
{
var customCodeObject = ModelMapper.Map <CustomCode, CustomCodeObject>(app);
if (customCodeObject != null && customCodeObject.CustomCodeId > 0)
{
objList.Add(customCodeObject);
}
});
return(!objList.Any() ? new List <CustomCodeObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public List <ImportClassObject> GetImportClasses()
{
try
{
using (var db = new ImportPermitEntities())
{
var importClasss = db.ImportClasses.OrderBy(m => m.Name).ToList();
if (!importClasss.Any())
{
return(new List <ImportClassObject>());
}
var objList = new List <ImportClassObject>();
importClasss.ForEach(app =>
{
var importClassObject = ModelMapper.Map <ImportClass, ImportClassObject>(app);
if (importClassObject != null && importClassObject.Id > 0)
{
objList.Add(importClassObject);
}
});
return(!objList.Any() ? new List <ImportClassObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public long AddSignDocument(SignOffDocumentObject document)
{
try
{
if (document == null)
{
return(-2);
}
var documentEntity = ModelMapper.Map <SignOffDocumentObject, SignOffDocument>(document);
if (documentEntity == null || string.IsNullOrEmpty(documentEntity.DocumentPath) || documentEntity.ApplicationId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var imApp = db.SignOffDocuments.Add(documentEntity);
db.SaveChanges();
return(imApp.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public ImportClassObject GetImportClass(long importClassId)
{
try
{
using (var db = new ImportPermitEntities())
{
var importClasss =
db.ImportClasses.Where(m => m.Id == importClassId)
.ToList();
if (!importClasss.Any())
{
return(new ImportClassObject());
}
var app = importClasss[0];
var importClassObject = ModelMapper.Map <ImportClass, ImportClassObject>(app);
if (importClassObject == null || importClassObject.Id < 1)
{
return(new ImportClassObject());
}
return(importClassObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new ImportClassObject());
}
}
public long UpdateImportClass(ImportClassObject importClass)
{
try
{
if (importClass == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.ImportClasses.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == importClass.Name.ToLower().Trim().Replace(" ", "") && g.Id != importClass.Id) > 0)
{
return(-3);
}
var importClassEntity = ModelMapper.Map <ImportClassObject, ImportClass>(importClass);
if (importClassEntity == null || importClassEntity.Id < 1)
{
return(-2);
}
db.ImportClasses.Attach(importClassEntity);
db.Entry(importClassEntity).State = EntityState.Modified;
db.SaveChanges();
return(importClass.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long AddImportClass(ImportClassObject importClass)
{
try
{
if (importClass == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.ImportClasses.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == importClass.Name.ToLower().Trim().Replace(" ", "")) > 0)
{
return(-3);
}
var importClassEntity = ModelMapper.Map <ImportClassObject, ImportClass>(importClass);
if (importClassEntity == null || string.IsNullOrEmpty(importClassEntity.Name))
{
return(-2);
}
var returnStatus = db.ImportClasses.Add(importClassEntity);
db.SaveChanges();
return(returnStatus.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long AddImportStage(ImportStageObject importStage)
{
try
{
if (importStage == null)
{
return(-2);
}
var importStageEntity = ModelMapper.Map <ImportStageObject, ImportStage>(importStage);
if (importStageEntity == null || string.IsNullOrEmpty(importStageEntity.Name))
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var returnStatus = db.ImportStages.Add(importStageEntity);
db.SaveChanges();
return(returnStatus.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public List <StructureObject> GetStructures()
{
try
{
using (var db = new ImportPermitEntities())
{
var structures = db.Structures.ToList();
if (!structures.Any())
{
return(new List <StructureObject>());
}
var objList = new List <StructureObject>();
structures.ForEach(app =>
{
var structureObject = ModelMapper.Map <Structure, StructureObject>(app);
if (structureObject != null && structureObject.StructureId > 0)
{
objList.Add(structureObject);
}
});
return(!objList.Any() ? new List <StructureObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public List <IssueLogObject> GetIssueLogs()
{
try
{
using (var db = new ImportPermitEntities())
{
var issueLogObjects = db.IssueLogs.ToList();
if (!issueLogObjects.Any())
{
return(new List <IssueLogObject>());
}
var objList = new List <IssueLogObject>();
issueLogObjects.ForEach(app =>
{
var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app);
if (issueLogObjectObject != null && issueLogObjectObject.Id > 0)
{
objList.Add(issueLogObjectObject);
}
});
return(!objList.Any() ? new List <IssueLogObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public long UpdateDocument(DocumentObject document)
{
try
{
if (document == null)
{
return(-2);
}
var documentEntity = ModelMapper.Map <DocumentObject, Document>(document);
if (documentEntity == null || documentEntity.DocumentId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Documents.Attach(documentEntity);
db.Entry(documentEntity).State = EntityState.Modified;
db.SaveChanges();
return(document.DocumentId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long AddCustomCode(CustomCodeObject customCode)
{
try
{
if (customCode == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.CustomCodes.Count(k => k.Name.ToLower().Trim() == customCode.Name.ToLower().Trim()) > 0)
{
return(-3);
}
var customCodeEntity = ModelMapper.Map <CustomCodeObject, CustomCode>(customCode);
if (customCodeEntity == null || string.IsNullOrEmpty(customCodeEntity.Name))
{
return(-2);
}
var returnStatus = db.CustomCodes.Add(customCodeEntity);
db.SaveChanges();
return(returnStatus.CustomCodeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateBankerDocument(DocumentObject document)
{
try
{
if (document == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var documentEntities = db.Documents.Where(d => d.DocumentId == document.DocumentId).ToList();
if (!documentEntities.Any())
{
return(-2);
}
var documentEntity = documentEntities[0];
documentEntity.DateUploaded = document.DateUploaded;
documentEntity.UploadedById = document.UploadedById;
documentEntity.DocumentPath = document.DocumentPath;
db.Entry(documentEntity).State = EntityState.Modified;
db.SaveChanges();
return(documentEntity.DocumentId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateCustomCode(CustomCodeObject customCode)
{
try
{
if (customCode == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.CustomCodes.Count(k => k.Name.ToLower().Trim() == customCode.Name.ToLower().Trim() && k.CustomCodeId == customCode.CustomCodeId) > 0)
{
return(-3);
}
var customCodeEntity = ModelMapper.Map <CustomCodeObject, CustomCode>(customCode);
if (customCodeEntity == null || customCodeEntity.CustomCodeId < 1)
{
return(-2);
}
db.CustomCodes.Attach(customCodeEntity);
db.Entry(customCodeEntity).State = EntityState.Modified;
db.SaveChanges();
return(customCode.CustomCodeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public List <DocumentObject> GetDocuments()
{
try
{
using (var db = new ImportPermitEntities())
{
var documents = db.Documents.ToList();
if (!documents.Any())
{
return(new List <DocumentObject>());
}
var objList = new List <DocumentObject>();
documents.ForEach(app =>
{
var documentObject = ModelMapper.Map <Document, DocumentObject>(app);
if (documentObject != null && documentObject.DocumentId > 0)
{
objList.Add(documentObject);
}
});
return(!objList.Any() ? new List <DocumentObject>() : objList);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(null);
}
}
public long AddAccountType(AccountTypeObject accountType)
{
try
{
if (accountType == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.AccountTypes.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == accountType.Name.ToLower().Trim().Replace(" ", "")) > 0)
{
return(-3);
}
var accountTypeEntity = ModelMapper.Map <AccountTypeObject, AccountType>(accountType);
if (accountTypeEntity == null || string.IsNullOrEmpty(accountTypeEntity.Name))
{
return(-2);
}
var returnStatus = db.AccountTypes.Add(accountTypeEntity);
db.SaveChanges();
return(returnStatus.AccountTypeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long AddIssueLog(IssueLogObject issueLogObject)
{
try
{
if (issueLogObject == null || issueLogObject.IssueCategoryId < 1)
{
return(-2);
}
var issueLogEntity = ModelMapper.Map <IssueLogObject, IssueLog>(issueLogObject);
if (issueLogEntity == null || issueLogEntity.IssueCategoryId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var processedLog = db.IssueLogs.Add(issueLogEntity);
db.SaveChanges();
return(processedLog.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public UserProfileObject GetUser(string id)
{
try
{
using (var db = new ImportPermitEntities())
{
var users =
db.AspNetUsers.Where(m => m.Id == id).Include("UserProfile")
.ToList();
if (!users.Any())
{
return(new UserProfileObject());
}
var appUser = users[0].UserProfile;
var userObject = ModelMapper.Map <UserProfile, UserProfileObject>(appUser);
if (userObject == null || userObject.Id < 1)
{
return(new UserProfileObject());
}
return(userObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new UserProfileObject());
}
}
public IssueLogObject GetIssueLog(long issueLogObjectId)
{
try
{
using (var db = new ImportPermitEntities())
{
var issueLogObjects =
db.IssueLogs.Where(m => m.Id == issueLogObjectId)
.ToList();
if (!issueLogObjects.Any())
{
return(new IssueLogObject());
}
var app = issueLogObjects[0];
var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app);
if (issueLogObjectObject == null || issueLogObjectObject.Id < 1)
{
return(new IssueLogObject());
}
return(issueLogObjectObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new IssueLogObject());
}
}
public long UpdateAccountType(AccountTypeObject accountType)
{
try
{
if (accountType == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.AccountTypes.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == accountType.Name.ToLower().Trim().Replace(" ", "") && g.AccountTypeId != accountType.AccountTypeId) > 0)
{
return(-3);
}
var accountTypeEntity = ModelMapper.Map <AccountTypeObject, AccountType>(accountType);
if (accountTypeEntity == null || accountTypeEntity.AccountTypeId < 1)
{
return(-2);
}
db.AccountTypes.Attach(accountTypeEntity);
db.Entry(accountTypeEntity).State = EntityState.Modified;
db.SaveChanges();
return(accountType.AccountTypeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public List <IssueLogObject> Search(string searchCriteria)
{
try
{
using (var db = new ImportPermitEntities())
{
var issueLogObjects =
db.IssueLogs.Where(m => m.IssueCategory.Name.ToLower().Trim() == searchCriteria.ToLower().Trim())
.ToList();
if (issueLogObjects.Any())
{
var newList = new List <IssueLogObject>();
issueLogObjects.ForEach(app =>
{
var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app);
if (issueLogObjectObject != null && issueLogObjectObject.Id > 0)
{
newList.Add(issueLogObjectObject);
}
});
return(newList);
}
}
return(new List <IssueLogObject>());
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new List <IssueLogObject>());
}
}
public long AddProductColumn(ProductColumnObject productColumn)
{
try
{
if (productColumn == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.ProductColumns.Count(k => k.CustomCodeId == productColumn.CustomCodeId && k.ProductId == productColumn.ProductId) > 0)
{
return(-3);
}
var productColumnEntity = ModelMapper.Map <ProductColumnObject, ProductColumn>(productColumn);
if (productColumnEntity == null || productColumnEntity.ProductId < 1 || productColumnEntity.CustomCodeId < 1)
{
return(-2);
}
var returnStatus = db.ProductColumns.Add(productColumnEntity);
db.SaveChanges();
return(returnStatus.ProductColumnId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateIssueLog(IssueLogObject issueLogObject)
{
try
{
if (issueLogObject == null)
{
return(-2);
}
var issueLogEntity = ModelMapper.Map <IssueLogObject, IssueLog>(issueLogObject);
if (issueLogEntity == null || issueLogEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.IssueLogs.Attach(issueLogEntity);
db.Entry(issueLogEntity).State = EntityState.Modified;
db.SaveChanges();
return(issueLogObject.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long DeleteProductColumn(long productColumnId)
{
try
{
using (var db = new ImportPermitEntities())
{
var myItems =
db.ProductColumns.Where(m => m.ProductColumnId == productColumnId).ToList();
if (!myItems.Any())
{
return(0);
}
var item = myItems[0];
db.ProductColumns.Remove(item);
db.SaveChanges();
return(5);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public StructureObject GetStructure(long structureId)
{
try
{
using (var db = new ImportPermitEntities())
{
var structures =
db.Structures.Where(m => m.StructureId == structureId)
.ToList();
if (!structures.Any())
{
return(new StructureObject());
}
var app = structures[0];
var structureObject = ModelMapper.Map <Structure, StructureObject>(app);
if (structureObject == null || structureObject.StructureId < 1)
{
return(new StructureObject());
}
return(structureObject);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(new StructureObject());
}
}
