/// <summary>
/// Save the modified or newly added roles into the database
/// </summary>
/// <param action="Data">List of roles to be saved</param>
/// <returns></returns>
public int Save(Roles Data)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Role efRole = null;
foreach (TopContractsDAL10.SystemTables.Role Role in Data.Entries)
{
if (Role.New)
{
efRole = new TopContractsEntities.Role();
}
else
{
efRole = context.Roles.Where(c => c.RoleID == Role.ID).SingleOrDefault();
}
if (efRole != null)
{
if (Role.CanEdit == true && efRole.Users.Any(u => u.Unrestricted == false))
{
throw new ExceptionSecurityAdminSaveRoleAssignedToRestrictedUser();
}
}
if (Role.Deleted == false)
{
efRole.InitCommonFields(efRole, Role, efRole.RolesLNGs, this.organizationIdentifier);
efRole.AddActivities = Role.AddActivities;
efRole.AddDocs = Role.AddDocs;
efRole.AddTodos = Role.AddTodos;
efRole.DeleteActivities = Role.DeleteActivities;
efRole.DeleteDocs = Role.DeleteDocs;
efRole.DeleteTodos = Role.DeleteTodos;
efRole.DisplayOrder = Role.DisplayOrder;
efRole.EditActivities = Role.EditActivities;
efRole.EditApps = Role.EditApps;
efRole.EditAuth = Role.EditAuth;
efRole.EditDocs = Role.EditDocs;
efRole.EditProperties = Role.EditProperties;
efRole.EditTodos = Role.EditTodos;
efRole.ModifyActivitiesOfOthers = Role.ModifyActivitiesOfOthers;
efRole.ModifyDocsOfOthers = Role.ModifyDocsOfOthers;
efRole.ModifyTodosOfOthers = Role.ModifyTodosOfOthers;
efRole.ViewActivities = Role.ViewActivities;
efRole.ViewActivitiesOfOthers = Role.ViewActivitiesOfOthers;
efRole.ViewApps = Role.ViewApps;
efRole.ViewAuth = Role.ViewAuth;
efRole.ViewDocs = Role.ViewDocs;
efRole.ViewDocsOfOthers = Role.ViewDocsOfOthers;
efRole.ViewProperties = true; // Role.ViewProperties; //HardCoded value true entered for roles in every condition on 6-Mar-2013
efRole.ViewTodos = Role.ViewTodos;
efRole.ViewTodosOfOthers = Role.ViewTodosOfOthers;
efRole.EditFields = Role.EditFields; // Added by Viplav on 7 Mar 2013 for implementing limited roles functionality
//******************************************************************
// New Properties Add for Image Gallery on 23-April-2013 by Viplav
//******************************************************************
efRole.ViewGallery = Role.ViewGallery;
efRole.EditGallery = Role.EditGallery;
efRole.AddGallery = Role.AddGallery;
efRole.DeleteGallery = Role.DeleteGallery;
efRole.ViewGalleryOfOthers = Role.ViewGalleryOfOthers;
efRole.ModifyGalleryOfOthers = Role.ModifyGalleryOfOthers;
}
if (Role.New)
context.Roles.Add(efRole);
else
{
if (Role.Deleted && efRole != null)
{
//******************Condition Implemented for delete entry from FieldGroupsRolesMAP by Viplav on 15-Oct-2013********//
if (context.FieldGroupsRolesMAPs.Any(ent => ent.RoleID == efRole.RoleID))
{
List<FieldGroupsRolesMAP> FieldGroupsRoleMap = context.FieldGroupsRolesMAPs.Where(t => t.RoleID == efRole.RoleID).ToList();
foreach (FieldGroupsRolesMAP item in FieldGroupsRoleMap)
context.FieldGroupsRolesMAPs.Remove(item);
}
//********************************************************************************************************************
efRole.DeleteLanguageEntries(efRole, context.RolesLNGs, efRole.RolesLNGs);
context.Roles.Remove(efRole);
}
}
}
//int Roweffected = context.SaveChanges();
ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
objectContext.DetectChanges();
int Roweffected = objectContext.SaveChanges(SaveOptions.None);
bool structuralChangeOccurred = false;
long nonStructuralChanges = 0;
foreach (var changedEntry in context.ChangeTracker.Entries())
{
if (changedEntry.Entity is TopContractsEntities.Role && changedEntry.State == System.Data.EntityState.Modified)
{
structuralChangeOccurred = IsRolePermissionsChanged(changedEntry);
if (structuralChangeOccurred == false)
nonStructuralChanges += 1;
}
else if (changedEntry.Entity is TopContractsEntities.Role && changedEntry.State == System.Data.EntityState.Added)
nonStructuralChanges += 1;
else if (changedEntry.Entity is TopContractsEntities.Role && changedEntry.State == System.Data.EntityState.Deleted)
nonStructuralChanges += 1;
else if (changedEntry.Entity is TopContractsEntities.RolesLNG && changedEntry.State == System.Data.EntityState.Modified)
nonStructuralChanges += 1;
//else if (changedEntry.Entity is TopContractsEntities.RolesLNG && changedEntry.State == System.Data.EntityState.Modified)
// nonStructuralChanges += 1;
}
objectContext.AcceptAllChanges();
// We use a default value 1 for check that only a single limited role is exist in the role table
if ((context.Roles.Count(rol => rol.EditFields == true) == 1) && context.FieldGroups.Any(fldgrp => fldgrp.RolesVisibility == (byte)FieldGroupRoleVisibility.VisibleToAll))
SaveFieldGroupsRolesMAPforLimitedUser();
ApplicationCachedData.reInitCacheData(); // To re-initialize server side cache.
if (structuralChangeOccurred)
ApplicationCachedData.UpdateContractStructureCacheTicks();
else
if (nonStructuralChanges > 0)
ApplicationCachedData.UpdateContractDisplayCacheTicks();
return Roweffected;
}
/// <summary>
/// Gets names of contracts by using IDs of the contracts
/// </summary>
/// <param name="ContractIDs">IDs of the contracts.</param>
/// <returns>List of TopContractsDAL10.ContractInfo objects containing names and Ids of the contracts.</returns>
public List<ContractInfo> GetContractsInfo(List<long> ContractIDs)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
List<ContractInfo> contractsInfo = new List<ContractInfo>();
contractsInfo.AddRange(context.Contracts.Where(c => ContractIDs.Contains(c.ContractID)).Select(c => new ContractInfo { ContractID = c.ContractID, Name = c.Name }));
return contractsInfo;
}
/// <summary>
/// Gets page size value from the AppSettings table in the database.
/// </summary>
/// <param name="OrganizationIdentifier">ID of the Orgainzation whose paging size is required.</param>
/// <param name="contractSection">Contract section whose paging size is required.</param>
/// <returns>An integer value. Can also be null.</returns>
public long? GetPagingValueFromDB(Guid OrganizationIdentifier, ContractSections contractSection)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
long? PageSize = null;
if (context.AppSettings.Any(org => org.OrganizationIdentifier == OrganizationIdentifier))
{
AppSetting efAppSettings = context.AppSettings.SingleOrDefault(org => org.OrganizationIdentifier == OrganizationIdentifier);
switch (contractSection)
{
case ContractSections.AuthorizedEntities:
PageSize = efAppSettings.MaxPageSizeUsers;
break;
case ContractSections.Documents:
PageSize = efAppSettings.MaxPageSizeDocs;
break;
case ContractSections.Events:
PageSize = efAppSettings.MaxPageSizeEvents;
break;
case ContractSections.Gallery:
PageSize = efAppSettings.MaxPageSizeGalleries;
break;
default:
break;
}
}
return PageSize;
}
public static void UpdateDocFileName(long docId, string FileName)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.ContractDoc efDoc = context.ContractDocs.SingleOrDefault(cd => cd.DocumentID == docId);
if (efDoc != null)
efDoc.FileName = FileName;
context.SaveChanges();
}
/// <summary>
/// Gets all Properties of a contract.
/// </summary>
/// <param name="CultureIdentifier">Culture identifier to be used to retrieve users information</param>
/// <returns>List of TopContractsDAL10.ContractUser objects.</returns>
public Dictionary<long, ContractProperties> GetAllContractProperties(string CultureIdentifier)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
Dictionary<long, ContractProperties> contractProperties = new Dictionary<long, ContractProperties>();
foreach (TopContractsEntities.Contract contract in context.Contracts)
{
ContractProperties cntprop = new ContractProperties();
cntprop.initDataFields(contract);
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Data Fields initialized");
cntprop.initPrivateFields(contract, CultureIdentifier);
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Private Fields initialized");
contractProperties.Add(contract.ContractID, cntprop);
}
return contractProperties;
}
/// <summary>
/// Used to check if the ContractID passed is a contract and not an entity.
/// </summary>
/// <param action="ContractID">Contract ID that has to be checked if it is a contract.</param>
/// <returns>Boolean value used to determine if the Contract ID is a contract and not an entity.</returns>
public static bool IsContract(long ContractID)
{
Logger.WriteGeneralVerbose("Contract class - IsContract", "checking if the contract id {0} passed is a contract and not an entity", ContractID);
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
//long ContractTypeContractsID = ConfigurationProvider.Default.ContractTypeContracts.ContractTypeContractsID;
long ContractTypeContractsID = Utilities.contractTypeContractsID; // Code implemented by Viplav on 17 june 2013 for remove webconfig concept
if (context.Contracts.Any(c => c.ContractID == ContractID && c.ContractType.ParentContractTypeID == ContractTypeContractsID))
return true;
else
return false;
}
public static void RemoveContractDocsDividerIfAny()
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
if (context.ContractDocs.Any(f => f.ExternalID.Contains(Constants.entityFieldsDivider)))
{
foreach (TopContractsEntities.ContractDoc cDoc in context.ContractDocs.Where(f => f.ExternalID.Contains(Constants.entityFieldsDivider)).ToList())
{
cDoc.ExternalID = cDoc.ExternalID.Substring(0, cDoc.ExternalID.IndexOf(Constants.entityFieldsDivider));
}
}
context.SaveChanges();
}
/// <summary>
/// Does contract exist with this ID?
/// </summary>
/// <param action="ContractID">Contract ID</param>
/// <returns>True or false</returns>
public static bool ContractExists(long ContractID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
return (context.Contracts.Where(c => c.ContractID == ContractID).SingleOrDefault() != null);
}
/// <summary>
/// Copy Contract Field (Copy Contracts Fields according to Contract Type)
/// </summary>
/// <param action="parentContractID">Id of parentContractID</param>
/// <param action="childContractID">Id of childContractID</param>
/// <param action="parentContractTypeID">Id of parentContractTypeID</param>
/// <param action="childContractTypeID">Id of childContractTypeID</param>
/// <param action="CultureIdentifier">CultureIdentifier</param>
/// <returns></returns>
public static void CopyContractField(long parentContractID, long childContractID, int parentContractTypeID, int childContractTypeID, string CultureIdentifier)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
if (parentContractTypeID == childContractTypeID)
{
foreach (var childContractField in context.ContractFields.Where(cFld => cFld.ContractID == childContractID).ToList())
{
context.ContractFields.Remove(childContractField);
}
foreach (var parentContractField in context.ContractFields.Where(cFld => cFld.ContractID == parentContractID).ToList())
{
TopContractsEntities.ContractField contractField = new TopContractsEntities.ContractField();
contractField = parentContractField;
contractField.ContractID = childContractID;
if (parentContractField.LinkedDocumentID != null && parentContractField.LinkedDocumentID > 0)
{
string docIdToSearch = (Constants.entityFieldsDivider + parentContractField.LinkedDocumentID + Constants.entityFieldsDivider);
if (context.ContractDocs.Any(cd => cd.ExternalID.Contains(docIdToSearch)) && context.ContractDocs.Count(cd => cd.ExternalID.Contains(docIdToSearch)) == 1)
{
long ContractDocID = context.ContractDocs.Single(cDoc => cDoc.ExternalID.Contains(docIdToSearch)).DocumentID;
contractField.LinkedDocumentID = ContractDocID;
}
}
context.ContractFields.Add(contractField);
}
}
else
{
List<int> commonFieldGroupIDs = getCommonContractFieldGroup(parentContractTypeID, childContractTypeID, CultureIdentifier);
foreach (int cfg in commonFieldGroupIDs)
{
foreach (var childContractField in context.ContractFields.Where(cFld => cFld.ContractID == childContractID && cFld.FieldGroupID == cfg).ToList())
{
context.ContractFields.Remove(childContractField);
}
foreach (var parentContractField in context.ContractFields.Where(cFld => cFld.ContractID == parentContractID && cFld.FieldGroupID == cfg).ToList())
{
TopContractsEntities.ContractField contractField = new TopContractsEntities.ContractField();
contractField = parentContractField;
contractField.ContractID = childContractID;
if (parentContractField.LinkedDocumentID != null && parentContractField.LinkedDocumentID > 0)
{
string docIdToSearch = (Constants.entityFieldsDivider + parentContractField.LinkedDocumentID + Constants.entityFieldsDivider);
if (context.ContractDocs.Any(cd => cd.ExternalID.Contains(docIdToSearch)) && context.ContractDocs.Count(cd => cd.ExternalID.Contains(docIdToSearch)) == 1)
{
long ContractDocID = context.ContractDocs.Single(cDoc => cDoc.ExternalID.Contains(docIdToSearch)).DocumentID;
contractField.LinkedDocumentID = ContractDocID;
}
}
context.ContractFields.Add(contractField);
}
}
}
context.SaveChanges();
}
private void updateEfContract(ref TopContractsEntities.Contract efContract, ref TopContractsV01Entities context)
{
if (this.Properties != null)
this.Properties.updateEfFields(ref efContract);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractActivity of {0}", this.ID);
//Logger.Write("updating ContractActivity of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractActivities != null)
foreach (ContractActivity activity in this.ContractActivities.Where(ent => (ent.Deleted && ent.New) != true))
activity.UpdateEntity(ref context, efContract.ContractActivities, context.ContractActivities, this.ID, this.Properties.OrganizationIdentifier);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractApplications of {0}", this.ID);
//Logger.Write("updating ContractApplications of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractApplications != null)
foreach (ContractApplication application in this.ContractApplications.Where(ent => (ent.Deleted && ent.New) != true))
application.UpdateEntity(ref context, efContract.ContractApplications, context.ContractApplications, this.ID, this.Properties.OrganizationIdentifier);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractDocs of {0}", this.ID);
//Logger.Write("updating ContractDocs of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractDocs != null)
foreach (ContractDoc doc in this.ContractDocs.Where(ent => (ent.Deleted && ent.New) != true))
doc.UpdateEntity(ref context, efContract.ContractDocs, context.ContractDocs, this.ID, this.Properties.OrganizationIdentifier);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractGalleries of {0}", this.ID);
if (this.ContractGalleries != null)
foreach (ContractGallery gallery in this.ContractGalleries.Where(ent => (ent.Deleted && ent.New) != true))
gallery.UpdateEntity(ref context, efContract.ContractGalleries, context.ContractGalleries, this.ID, this.Properties.OrganizationIdentifier);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractFieldGroups of {0}", this.ID);
//Logger.Write("updating ContractFieldGroups of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractFieldGroups != null)
foreach (ContractFieldGroup FieldGroup in this.ContractFieldGroups.Where(ent => (ent.Deleted && ent.New) != true))
FieldGroup.UpdateEntity(ref context, efContract.ContractFields, null, ID, this.Properties.OrganizationIdentifier);
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractTodos of {0}", this.ID);
//Logger.Write("updating ContractTodos of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractTodos != null)
foreach (ContractTodo Todo in this.ContractTodos.Where(ent => (ent.Deleted && ent.New) != true))
//Todo.UpdateEntity(ref context, efContract.ContractTodos, efContract.ContractActivities.First().ContractTodos, this.ID);
Todo.UpdateEntity(ref context, efContract.ContractTodos, context.ContractTodos, this.ID, this.Properties.OrganizationIdentifier);
//var xxxx = efContract.ContractActivities.FirstOrDefault().ContractTodos;
//var yyyy = context.ContractTodos;
Logger.WriteGeneralVerbose("Contract class - updateEfContract", "updating ContractUsers of {0}", this.ID);
//Logger.Write("updating ContractUsers of " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
if (this.ContractUsers != null)
foreach (ContractUser User in this.ContractUsers.Where(ent => (ent.Deleted && ent.New) != true))
User.UpdateEntity(ref context, efContract.ContractUsers, context.ContractUsers, this.ID, this.Properties.OrganizationIdentifier);
}
/// <summary>
/// This constructor is ONLY used for creating new contracts, not for getting information about existing contracts.
/// </summary>
/// <param action="ContractName">The action for the new contract being created</param>
/// <param action="ContractTypeID">The type for the new contract being created</param>
/// <param action="ContractStatusID">The status for the new contract being created</param>
/// <param action="UserIdCreator">The ID of the user creating the contract</param>
/// <param action="CultureIdentifier">Culture Identifier used for the selection of Fields and Field-Groups
/// names in the appropriate language, in the process of creating those for the contract. The language
/// is not needed for the creation, so much as it is needed for the population of data in the newly created contract</param>
public Contract(Guid OrganizationIdentifier, string ContractName, long ContractTypeID, long? ContractStatusID, long UserIdCreator, string CultureIdentifier, long RoleID = 0)
{
//int RoleIdCreator = (int)SpecialRoles.OwnerRoleID; //Always the "owner" is the one creating the contracts...
long RoleIdCreator = RoleID; //RoleID is a default userid used for contractuser table
try
{
Deleted = false;
Properties = new ContractProperties();
initLists();
New = true;
Properties.Name = ContractName;
Properties.ContractTypeID = ContractTypeID;
Properties.StatusID = (int?)ContractStatusID;
Properties.OrganizationIdentifier = OrganizationIdentifier;
ContractUsers.Add(new ContractUser() { New = true, EntryId = UserIdCreator, RoleID = RoleIdCreator });
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
//long ContractTypeContractsID = ConfigurationProvider.Default.ContractTypeContracts.ContractTypeContractsID;
long ContractTypeContractsID = Utilities.contractTypeContractsID; // Code implemented by Viplav on 17 june 2013 for remove webconfig concept
TopContractsDAL10.SystemTables.FieldGroups fieldGroups = new SystemTables.FieldGroups();
if (context.ContractTypes.Any(ct => ct.ParentContractTypeID == ContractTypeContractsID && ct.ContractTypeID == ContractTypeID))
fieldGroups = SystemTables.FieldGroups.Get(false, false, true, CultureIdentifier);
else
fieldGroups = SystemTables.FieldGroups.GetWithoutParentContractTypeID(false, false, true, CultureIdentifier);
string logData1 = "FieldGroups created: " + Environment.NewLine;
foreach (TopContractsDAL10.SystemTables.FieldGroup fGrp in fieldGroups.Entries)
{
logData1 = logData1 + string.Format("FieldGroup info: groupID-{0}", fGrp.ID) + Environment.NewLine;
}
Logger.WriteGeneralVerbose("Contract class - CTOR", logData1);
Logger.WriteGeneralVerbose("Contract class - CTOR", "Creating FieldGroups collection");
foreach (TopContractsDAL10.SystemTables.FieldGroup fieldGroup in fieldGroups.Entries)
{
//if (fieldGroup.ContractTypeIDsVisible.Any(ct => ct == ContractTypeID)) //Boaz - 7-Aug-2012
if (context.ContractTypes.Any(ct => ct.ParentContractTypeID == ContractTypeContractsID && ct.ContractTypeID == ContractTypeID))
{
if (fieldGroup.ContractTypeIDsVisible.Any(ct => ct == ContractTypeID) || fieldGroup.VisibleToAllContractTypes)
ContractFieldGroups.Add(new ContractFieldGroup(fieldGroup, CultureIdentifier));
}
else
{
if (fieldGroup.ContractTypeIDsVisible.Any(ct => ct == ContractTypeID))
ContractFieldGroups.Add(new ContractFieldGroup(fieldGroup, CultureIdentifier));
}
}
string logData2 = "ContractFieldGroups created: " + Environment.NewLine;
foreach (ContractFieldGroup cFldGrp in ContractFieldGroups)
{
logData2 = logData2 + string.Format("FieldGroup info: groupID-{0}", cFldGrp.EntryId) + Environment.NewLine;
}
Logger.WriteGeneralVerbose("Contract class - CTOR", logData2);
}
catch (Exception ex)
{
Logger.WriteExceptionError("Contract class - Contract", ex);
ErrorDTO Error = new ErrorDTO(new ExceptionUnknownContractInit(ex));
}
}
public long SaveEntityRecord(int UpdatingUserID, bool AuditChanges)
{
Logger.Write(LogCategory.General, (this.New ? "Creating new " : (this.Deleted ? "Deleting " : "Updating ")) + "contract", "contract ID " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
DateTime updateDate = DateTime.Now;
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Contract efContract = null;
if (this.New)
{
efContract = new TopContractsEntities.Contract();
efContract.ContractUpdateDetail = new ContractUpdateDetail();
if (context.FieldGroups.Count(grp => grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && grp.FieldGroupsContractTypesMAPs.Any(mp => mp.ContractTypeID == this.Properties.ContractTypeID)) > 0)
foreach (FieldGroup grp in context.FieldGroups.Where(grp => grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && grp.Inactive == false && grp.FieldGroupsContractTypesMAPs.Any(mp => mp.ContractTypeID == this.Properties.ContractTypeID)))//Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fieldsgroup
foreach (Field fld in grp.Fields.Where(grpf => grpf.Inactive == false)) //Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fields
{
efContract.ContractFields.Add(new TopContractsEntities.ContractField() { OrganizationIdentifier = this.Properties.OrganizationIdentifier, FieldGroupID = grp.EntryIdentifier, FieldID = fld.EntryIdentifier, FieldValue = (fld.FieldType == (int)FieldTypes.ListSingle && fld.UseFirstAsDefault == true ? fld.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
}
}
else
{
efContract = context.Contracts.Where(u => u.ContractID == this.ID).SingleOrDefault();
}
if (this.Deleted)
{
#region DELETING RELATED ENTITIES -----------------------------------------------------------------------------
//For some unknown reason, eliminating the if-count>0 from before each of the foreach(s), throws an "object not set" exception even though alerts exist!
context.ContractUpdateDetails.Remove(context.ContractUpdateDetails.Single(entry => entry.ContractID == this.ID));
if (context.ContractFields.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractField efContractField in context.ContractFields.Where(entry => entry.ContractID == this.ID))
context.ContractFields.Remove(efContractField);
foreach (TopContractsEntities.ContractUser efContractUser in context.ContractUsers.Where(entry => entry.ContractID == this.ID))
context.ContractUsers.Remove(efContractUser);
#endregion
context.Contracts.Remove(efContract);
}
if (this.New)
{
updateEfContract(ref efContract, ref context);
context.Contracts.Add(efContract);
}
if (this.New == false & this.Deleted == false)
{
updateEfContract(ref efContract, ref context);
}
//Boaz-1 (8-Aug-2012) ------------------------------------------------------
//All Todos which are linked to new events, should be made their "children" in the EF so that the foreign
//key values will be automatically generated when saving to the DB
foreach (TopContractsEntities.ContractTodo todo in efContract.ContractTodos.Where(td => td.ActivityID < 0))
{
efContract.ContractActivities.SingleOrDefault(ca => ca.ActivityID == todo.ActivityID).ContractTodos.Add(todo);
}
bool updateContractUpdateDetails = false;
if (this.Deleted == false)
{
//If any of the entities related to the contract has changed, the Update-Date of the contract record itself should be updated...
foreach (var entry in context.ChangeTracker.Entries())
{
//Boaz 7-Aug-2012
//if (entry.State == System.Data.EntityState.Added || entry.State == System.Data.EntityState.Modified && !(entry.Entity is EFContractRelatedEntryWithUpdate))
if (entry.State == System.Data.EntityState.Added || entry.State == System.Data.EntityState.Modified || entry.State == System.Data.EntityState.Deleted)
{
updateContractUpdateDetails = true;
}
}
if (updateContractUpdateDetails)
foreach (var entry in context.ChangeTracker.Entries())
{
//Boaz 7-Aug-2012
//If any changed was made to a record in any table (entities related to the contract) which has
//UpdateDate and UpdateUserID fields, these fields are updated to reflect the change.
//These fields are NOT handled by the individual classes committing the changes to the
//database - they are handled centrally here to cut-down on the code
if (entry.Entity is EFContractRelatedEntryWithUpdate && entry.State != EntityState.Unchanged)
//if (entry.Entity is EFContractRelatedEntryWithUpdate)
{
((EFContractRelatedEntryWithUpdate)entry.Entity).UpdatingDate = updateDate;
((EFContractRelatedEntryWithUpdate)entry.Entity).UpdatingUserID = UpdatingUserID;
}
}
}
if (updateContractUpdateDetails)
{
efContract.ContractUpdateDetail.UpdateDate = updateDate;
efContract.ContractUpdateDetail.UpdateUserID = UpdatingUserID;
}
//We want to keep tracking the changes after calling SaveChanges, for the purpose of auditing
ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
objectContext.DetectChanges();
try
{
//Using SaveOptions.None to keep change-tracking... Requires objectContext.DetectChanges() before and objectContext.AcceptAllChanges() after...
int rowsAffected = objectContext.SaveChanges(SaveOptions.None);
}
catch (System.Data.UpdateException updEx)
{
if (updEx.InnerException != null)
if (updEx.InnerException.Message.Contains("DELETE statement conflicted with the REFERENCE constraint") &&
updEx.InnerException.Message.Contains("FK_ContractTodos_ContractActivities"))
//{
// Logger.Write(updEx, System.Diagnostics.TraceEventType.Warning);
throw new ExceptionDataContractSaveDeleteEventWithAlert();
//}
else if (updEx.InnerException.Message.Contains("FK_Contracts_Contracts") &&
updEx.InnerException.Message.Contains("ParentContractID"))
throw new ExceptionDataContractDeleteDeleteContractWithChild();
else
//{
// Logger.Write(updEx, System.Diagnostics.TraceEventType.Error);
throw updEx;
//}
}
if (AuditChanges)
{
HistManager histManager = new HistManager();
int recordsWrittenToHistory = histManager.AuditChanges(updateDate, UpdatingUserID, this.New, this.Deleted, context.ChangeTracker.Entries().Where(e => e.State != System.Data.EntityState.Unchanged || e.Entity is TopContractsEntities.Contract));
}
objectContext.AcceptAllChanges();
long contractIdSaved = -1; //will indicate failure, if no number is set
foreach (var entry in context.ChangeTracker.Entries())
{
Logger.Write("entering the loop - for context.ChangeTracker.Entries()", System.Diagnostics.TraceEventType.Verbose);
if (entry.Entity is TopContractsEntities.Contract)
{
contractIdSaved = ((TopContractsEntities.Contract)entry.Entity).ContractID;
}
if (entry.Entity is TopContractsEntities.ContractDoc)
{
TopContractsEntities.ContractDoc efDoc = entry.Entity as TopContractsEntities.ContractDoc;
TopContractsDAL10.ContractDoc doc = this.ContractDocs.SingleOrDefault(d => d.FileName == efDoc.FileName);
if (doc != null)
{
if (doc.New)
{
doc.EntryId = efDoc.DocumentID; //This is done especially for the process of file copying...
}
}
}
}
if (this.Deleted)
return 0;
return contractIdSaved;
}
/// <summary>
/// Save the field groups and its fields into the database.
/// </summary>
/// <param action="Data">Collection of field groups which are getting saved.</param>
/// <param action="AuditChanges">A boolean value equal to true, if application license allows audit changes.</param>
/// <param action="UpdatingUserID">Id of the user who is updating the field groups.</param>
/// <param action="CascadeDelete">Boolean value if cascade deletion is bieng done.</param>
/// <returns>Returns an integer value for the total number of records being updated.</returns>
//public static int SaveFields(FieldGroups Data, bool AuditChanges, long UpdatingUserID, bool CascadeDelete)
public int SaveFields(FieldGroups Data, bool AuditChanges, long UpdatingUserID, bool CascadeDelete, ref Dictionary<int, long> EntityFieldIDsMap, bool isCatalogField, bool populateMapDictionary = false)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.FieldGroup efFieldGroup = null;
Dictionary<long, long> checkMax = new Dictionary<long, long>();
TopContractsEntities.Field efField = null;
TopContractsEntities.FieldListItem efFieldListItem = null;
foreach (TopContractsDAL10.SystemTables.FieldGroup fieldGroup in Data.Entries)
{
if (fieldGroup.New)
{
efFieldGroup = new TopContractsEntities.FieldGroup();
}
else
{
efFieldGroup = context.FieldGroups.Where(c => c.FieldGroupID == fieldGroup.ID).SingleOrDefault();
}
if (fieldGroup.Deleted == false)
{
efFieldGroup.InitCommonFields(efFieldGroup, fieldGroup, efFieldGroup.FieldGroupsLNGs, this.organizationIdentifier);
efFieldGroup.DisplayIndependent = fieldGroup.DisplayIndependent;
if (fieldGroup.VisibleToAllContractTypes)
{
efFieldGroup.ContractTypeVisibility = (byte)FieldGroupContractTypeVisibility.VisibleToAll;
if (efFieldGroup.FieldGroupsContractTypesMAPs != null)
{
for (int i = efFieldGroup.FieldGroupsContractTypesMAPs.Count - 1; i >= 0; i--)
{
FieldGroupsContractTypesMAP map = efFieldGroup.FieldGroupsContractTypesMAPs.ElementAt(i);
efFieldGroup.FieldGroupsContractTypesMAPs.Remove(map);
context.FieldGroupsContractTypesMAPs.Remove(map);
}
}
}
else
{ //TODO - add implementation for FieldGroupContractTypeVisibility.HiddenFromTypes
efFieldGroup.ContractTypeVisibility = (byte)FieldGroupContractTypeVisibility.VisibleToTypes;
if (efFieldGroup.FieldGroupsContractTypesMAPs != null)
{
//Removing those who are missing from the received list
for (int i = efFieldGroup.FieldGroupsContractTypesMAPs.Count - 1; i >= 0; i--)
{
FieldGroupsContractTypesMAP map = efFieldGroup.FieldGroupsContractTypesMAPs.ElementAt(i);
if (fieldGroup.ContractTypeIDsVisible != null)
{
if (fieldGroup.ContractTypeIDsVisible.Any(v => v == map.ContractTypeID) == false)
{
if (CascadeDelete)
{
foreach (TopContractsEntities.Contract contract in map.ContractType.Contracts)
{
foreach (TopContractsEntities.Field fld in efFieldGroup.Fields)
{
//Changed by Boaz 16-05-2013: field-id is not used properly in case of catalog-fields - it should be replaced with the "fld.ContractType.SelectorFieldID" for the deletion purpose
long fieldID = getFieldIdForContractFields(fld);
if (fld.FieldType == (long)FieldTypes.EntityLink)
{
if (contract.ContractFields.Any(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID && cf.CatalogFieldID == fieldID))
{
foreach (long recordCounter in contract.ContractFields.Where(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID && cf.CatalogFieldID == fieldID).Select(u => u.RecordCounter).ToList())
{
context.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID && cf.CatalogFieldID == fieldID && cf.RecordCounter == recordCounter));
}
}
//context.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID && cf.CatalogFieldID == fieldID));
}
else
{
if (contract.ContractFields.Any(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID))
{
foreach (long recordCounter in contract.ContractFields.Where(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fld.FieldID).Select(u => u.RecordCounter).ToList())
{
context.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fieldID && cf.RecordCounter == recordCounter));
}
}
//context.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldGroupID == fld.FieldGroupID && cf.FieldID == fieldID ));
}
}
}
}
efFieldGroup.FieldGroupsContractTypesMAPs.Remove(map);
context.FieldGroupsContractTypesMAPs.Remove(map);
}
}
else
{
if (CascadeDelete)
{
foreach (TopContractsEntities.Contract contract in map.ContractType.Contracts)
{
for (int j = contract.ContractFields.Count - 1; j >= 0; j--)
{
contract.ContractFields.Remove(contract.ContractFields.ElementAt(j));
}
}
}
efFieldGroup.FieldGroupsContractTypesMAPs.Remove(map);
context.FieldGroupsContractTypesMAPs.Remove(map);
}
}
}
//Adding entries from the received list which don't exist yet
if (fieldGroup.ContractTypeIDsVisible != null)
{
foreach (int indx in fieldGroup.ContractTypeIDsVisible)
if (efFieldGroup.FieldGroupsContractTypesMAPs.Any(v => v.ContractTypeID == indx) == false)
efFieldGroup.FieldGroupsContractTypesMAPs.Add(new FieldGroupsContractTypesMAP() { OrganizationIdentifier = this.organizationIdentifier, ContractTypeID = indx, FieldGroupID = (int)fieldGroup.ID });
}
}
if (fieldGroup.VisibleToAllRoles)
{
efFieldGroup.RolesVisibility = (byte)FieldGroupRoleVisibility.VisibleToAll;
if (efFieldGroup.FieldGroupsRolesMAPs != null)
{
for (int i = efFieldGroup.FieldGroupsRolesMAPs.Count - 1; i >= 0; i--)
{
FieldGroupsRolesMAP map = efFieldGroup.FieldGroupsRolesMAPs.ElementAt(i);
efFieldGroup.FieldGroupsRolesMAPs.Remove(map);
context.FieldGroupsRolesMAPs.Remove(map);
}
}
}
else
{ //TODO - add implementation for FieldGroupRoleVisibility.HiddenFromRoles
efFieldGroup.RolesVisibility = (byte)FieldGroupRoleVisibility.VisibleToRoles;
if (efFieldGroup.FieldGroupsRolesMAPs != null)
{
//Removing those who are missing from the received list
for (int i = efFieldGroup.FieldGroupsRolesMAPs.Count - 1; i >= 0; i--)
{
FieldGroupsRolesMAP map = efFieldGroup.FieldGroupsRolesMAPs.ElementAt(i);
if (fieldGroup.RoleIDsVisible != null)
{
if (fieldGroup.RoleIDsVisible.Any(v => v == map.RoleID) == false)
{
efFieldGroup.FieldGroupsRolesMAPs.Remove(map);
context.FieldGroupsRolesMAPs.Remove(map);
}
}
else
{
efFieldGroup.FieldGroupsRolesMAPs.Remove(map);
context.FieldGroupsRolesMAPs.Remove(map);
}
}
}
//Adding entries from the received list which don't exist yet
if (fieldGroup.RoleIDsVisible != null)
{
foreach (int indx in fieldGroup.RoleIDsVisible)
if (efFieldGroup.FieldGroupsRolesMAPs.Any(v => v.RoleID == indx) == false)
efFieldGroup.FieldGroupsRolesMAPs.Add(new FieldGroupsRolesMAP() { OrganizationIdentifier = this.organizationIdentifier, RoleID = indx, FieldGroupID = (int)fieldGroup.ID, AllowView = true, AllowEdit = fieldGroup.RoleIDsEditable.Any(x => x == indx) });
else
{
efFieldGroup.FieldGroupsRolesMAPs.Single(v => v.RoleID == indx).AllowView = true;
efFieldGroup.FieldGroupsRolesMAPs.Single(v => v.RoleID == indx).AllowEdit = fieldGroup.RoleIDsEditable.Any(x => x == indx);
}
}
}
if (fieldGroup.New == false)
{
// code to change record counters for the contracts fields (i.e from -999999 to 1) when a
// single record field group is converted into a multiple record field group.
if (context.FieldGroups.SingleOrDefault(fg => fg.FieldGroupID == efFieldGroup.FieldGroupID).SingleRecord == true && fieldGroup.SingleRecord == false)
{
List<TopContractsEntities.ContractField> contractFldsToRemoveIfAny = new List<TopContractsEntities.ContractField>();
foreach (TopContractsEntities.ContractField cFld in efFieldGroup.ContractFields)
{
if (cFld.RecordCounter > 0)
contractFldsToRemoveIfAny.Add(cFld);
else if (cFld.RecordCounter == (long)RecordCounter.Default)
cFld.RecordCounter = 1;
}
if (contractFldsToRemoveIfAny.Count > 0)
foreach (TopContractsEntities.ContractField contractFldToRemove in contractFldsToRemoveIfAny)
{
context.ContractFields.Remove(contractFldToRemove);
}
}
}
efFieldGroup.SingleRecord = fieldGroup.SingleRecord;
// code area to remove contract fields if field group is being changed from multiple
// record to single record.
if (Convert.ToBoolean(efFieldGroup.SingleRecord) && efFieldGroup.ContractFields.Count > 0)
{
List<TopContractsEntities.ContractField> contractFldsToRemove = new List<TopContractsEntities.ContractField>();
if (efFieldGroup.ContractFields.Any(cf => cf.RecordCounter > 0))
{
List<long> mappedContractIds = efFieldGroup.ContractFields.Where(cf => cf.RecordCounter > 0).Select(cf => cf.ContractID).Distinct().ToList();
foreach (long mappedContractId in mappedContractIds)
{
foreach (TopContractsEntities.ContractField contractFld in efFieldGroup.ContractFields.Where(ctFld => ctFld.ContractID == mappedContractId && ctFld.FieldGroupID == efFieldGroup.FieldGroupID))
{
if (contractFld.RecordCounter == 1)
{
contractFld.RecordCounter = (long)RecordCounter.Default;
contractFld.FieldValue = null;
contractFld.LinkedUserID = null;
contractFld.FieldValueNumeric = null;
contractFld.FieldValueDate = null;
contractFld.FieldValueTime = null;
contractFld.FieldCurrencyID = null;
contractFld.LinkedEventID = null;
contractFld.LinkedUserID = null;
contractFld.LinkedDocumentID = null;
contractFld.LinkedContractID = null;
}
else
contractFldsToRemove.Add(contractFld);
}
}
}
if (contractFldsToRemove.Count > 0)
foreach (TopContractsEntities.ContractField contractFldToRemove in contractFldsToRemove)
{
context.ContractFields.Remove(contractFldToRemove);
}
}
if (fieldGroup.GroupFields == null)
{
//do nothing here - no fields
}
else
{
foreach (TopContractsDAL10.SystemTables.Field field in fieldGroup.GroupFields.Entries)
{
if (field.New)
{
efField = new TopContractsEntities.Field();
}
else
{
efField = context.Fields.Where(c => c.FieldID == field.ID).SingleOrDefault();
}
if (field.Deleted == false)
{
efField.InitCommonFields(efField, field, efField.FieldsLNGs, this.organizationIdentifier);
efField.FieldLength = field.FieldLength;
efField.UseFirstAsDefault = field.UseFirstAsDefault;
efField.FieldType = field.FieldType;
efField.Mandatory = field.Mandatory;
efField.AllowMultipleSelection = field.AllowMultipleSelection;
efField.MandatoryCurrencyID = field.MandatoryCurrencyID;
efField.DisplayFormat = field.DisplayFormat;
efField.MandatoryEventTypeID = field.MandatoryEventTypeID;
efField.Formula = field.Formula;
efField.IsCalculatedCurrency = field.IsCalculatedCurrency;
efField.FieldIDForCurrency = field.FieldIDForCurrency;
efField.AllowUnauthorizedUsers = field.AllowUnauthorizedUsers;
efField.LinkedFieldID = field.LinkedFieldID;
efField.DefaultValue = field.DefaultValue;
efField.IsWholeNumber = field.IsWholeNumber;
efField.MinimumNumericValue = field.MinimumNumericValue;
efField.MaximumNumericValue = field.MaximumNumericValue;
//if (!string.IsNullOrEmpty(field.ExternalID))
// efField.ExternalID = field.ExternalID.Substring(0, field.ExternalID.IndexOf(Constants.entityFieldsDivider));
//Modified by Salil on 19-July-2013;
//this condition is true if the catalog field is changed in fieldgroup. Eg:- Catalog A is replcaed by Catalog B in a FieldGroup FG.
if (efField.LinkedEntityID != field.LinkedEntityID)
{
List<long> ctlFldLst = context.ContractTypesFieldsToCreateDefaults.Where(t => t.ContractTypeID == efField.LinkedEntityID).Select(t => t.FieldID).ToList();
foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(fld => fld.FieldGroupID == fieldGroup.ID && fld.FieldID == field.ID && fld.CatalogFieldID != null && ctlFldLst.Contains((long)fld.CatalogFieldID)).ToList())
{
context.ContractFields.Remove(contractField);
}
}
efField.LinkedEntityID = field.LinkedEntityID;
//if (field.FieldListItems != null && field.FieldType == (int)FieldTypes.ListSingle)
if (field.FieldListItems != null)
{
if (field.FieldListItems.Entries.Count > 0)
{
//------------------------------------------------
foreach (TopContractsDAL10.SystemTables.FieldListItem fieldListItem in field.FieldListItems.Entries)
{
if (fieldListItem.New)
{
efFieldListItem = new TopContractsEntities.FieldListItem();
}
else
{
efFieldListItem = context.FieldListItems.Where(c => c.FieldListItemID == fieldListItem.ID).SingleOrDefault();
}
if (fieldListItem.Deleted == false)
{
efFieldListItem.InitCommonFields(efFieldListItem, fieldListItem, efFieldListItem.FieldListItemsLNGs, this.organizationIdentifier);
//efFieldListItem.FieldID = (int)fieldListItem.FieldID;
//TODO - any more?...
}
if (fieldListItem.New)
efField.FieldListItems.Add(efFieldListItem);
else
{
if (fieldListItem.Deleted && efFieldListItem != null)
{
if (CascadeDelete)
{
string strFieldListItemID = fieldListItem.ID.ToString();
var t = context.Contracts.Where(ct => ct.ContractFields.Any(ctfld => ctfld.FieldID == field.ID && ctfld.FieldValue == strFieldListItemID));
foreach (TopContractsEntities.Contract contract in context.Contracts.Where(ct => ct.ContractFields.Any(ctfld => ctfld.FieldID == field.ID && ctfld.FieldValue == strFieldListItemID)))
{
if (field.FieldType == (int)FieldTypes.ListSingle)
foreach (var ctrlfld in contract.ContractFields.Where(ctfld => ctfld.FieldID == field.ID && ctfld.FieldValue == strFieldListItemID))
ctrlfld.FieldValue = null;
else
contract.ContractFields.Where(ctfld => ctfld.FieldID == field.ID).SingleOrDefault().FieldValue = null;
}
if (context.ContractFields.Any(ctfld => ctfld.CatalogFieldID == field.ID && ctfld.FieldValue == strFieldListItemID))
{
foreach (TopContractsEntities.Contract contract in context.Contracts.Where(ct => ct.ContractFields.Any(ctfld => ctfld.CatalogFieldID == field.ID && ctfld.FieldValue == strFieldListItemID)))
{
if (field.FieldType == (int)FieldTypes.ListSingle)
foreach (var ctrlfld in contract.ContractFields.Where(ctfld => ctfld.CatalogFieldID == field.ID && ctfld.FieldValue == strFieldListItemID))
ctrlfld.FieldValue = null;
}
}
}
efFieldListItem.DeleteLanguageEntries(efFieldListItem, context.FieldListItemsLNGs, efFieldListItem.FieldListItemsLNGs);
efFieldListItem.Field.FieldListItems.Remove(efFieldListItem);
context.FieldListItems.Remove(efFieldListItem);
}
}
}
}
//------------------------------------------------
}
//TODO - any more?...
}
if (field.New)
efFieldGroup.Fields.Add(efField);
else
{
if (field.Deleted && efField != null)
{
//if (CascadeDelete && efField.FieldGroup.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll)
//{
// foreach (TopContractsEntities.Contract contract in context.Contracts)
// {
// contract.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldID == efField.EntryIdentifier));
// }
// foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(cf => cf.FieldID == efField.EntryIdentifier))
// {
// context.ContractFields.Remove(contractField);
// }
//}
//if (CascadeDelete && efField.FieldGroup.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && efField.FieldGroup.FieldGroupsContractTypesMAPs != null)
//{
// foreach (TopContractsEntities.FieldGroupsContractTypesMAP contractTypeMap in efField.FieldGroup.FieldGroupsContractTypesMAPs)
// {
// foreach (TopContractsEntities.Contract contract in contractTypeMap.ContractType.Contracts)
// {
// contract.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldID == efField.EntryIdentifier));
// }
// foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(cf => cf.FieldID == efField.EntryIdentifier))
// {
// context.ContractFields.Remove(contractField);
// }
// }
//}
if (CascadeDelete)
{
foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(fld => fld.FieldID == efField.FieldID).ToList())
{
context.ContractFields.Remove(contractField);
}
if (efFieldGroup.FieldGroupsContractTypesMAPs.Count() == 1)
{
long ContractTypeContractID = Utilities.contractTypeContractsID;
if (efFieldGroup.FieldGroupsContractTypesMAPs.First().ContractType.ParentContractTypeID != ContractTypeContractID || efFieldGroup.FieldGroupsContractTypesMAPs.First().ContractType.ParentContractTypeID == null)
{
foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(fld => fld.CatalogFieldID == efField.FieldID).ToList())
{
context.ContractFields.Remove(contractField);
}
}
}
}
efField.DeleteLanguageEntries(efField, context.FieldsLNGs, efField.FieldsLNGs);
for (int indx = efField.FieldListItems.Count() - 1; indx >= 0; indx--)
{
TopContractsEntities.FieldListItem itm = efField.FieldListItems.ElementAt(indx);
itm.DeleteLanguageEntries(itm, context.FieldListItemsLNGs, itm.FieldListItemsLNGs);
context.FieldListItems.Remove(itm);
}
efField.FieldGroup.Fields.Remove(efField);
context.Fields.Remove(efField);
}
}
}
}
}
if (fieldGroup.New)
context.FieldGroups.Add(efFieldGroup);
else
{
if (fieldGroup.Deleted && efFieldGroup != null)
{
efFieldGroup.DeleteLanguageEntries(efFieldGroup, context.FieldGroupsLNGs, efFieldGroup.FieldGroupsLNGs);
for (int indx = efFieldGroup.Fields.Count() - 1; indx >= 0; indx--)
{
TopContractsEntities.Field fld = efFieldGroup.Fields.ElementAt(indx);
fld.DeleteLanguageEntries(fld, context.FieldsLNGs, fld.FieldsLNGs);
for (int indx2 = fld.FieldListItems.Count() - 1; indx2 >= 0; indx2--)
{
TopContractsEntities.FieldListItem itm = fld.FieldListItems.ElementAt(indx2);
itm.DeleteLanguageEntries(itm, context.FieldListItemsLNGs, itm.FieldListItemsLNGs);
context.FieldListItems.Remove(itm);
}
//if (CascadeDelete && fld.FieldGroup.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll)
//{
// foreach (TopContractsEntities.Contract contract in context.Contracts)
// {
// contract.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldID == fld.EntryIdentifier));
// }
// foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(cf => cf.FieldID == fld.EntryIdentifier))
// {
// context.ContractFields.Remove(contractField);
// }
//}
//if (CascadeDelete && fld.FieldGroup.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && fld.FieldGroup.FieldGroupsContractTypesMAPs != null)
//{
// foreach (TopContractsEntities.FieldGroupsContractTypesMAP contractTypeMap in fld.FieldGroup.FieldGroupsContractTypesMAPs)
// {
// foreach (TopContractsEntities.Contract contract in contractTypeMap.ContractType.Contracts)
// {
// contract.ContractFields.Remove(contract.ContractFields.Single(cf => cf.FieldID == fld.EntryIdentifier));
// }
// foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(cf => cf.FieldID == fld.EntryIdentifier))
// {
// context.ContractFields.Remove(contractField);
// }
// }
//}
// Mohit - Added code to remove all the contract field of a Field group being removed.
if (CascadeDelete)
foreach (TopContractsEntities.ContractField contractField in context.ContractFields.Where(fg => fg.FieldGroupID == efFieldGroup.FieldGroupID).ToList())
{
context.ContractFields.Remove(contractField);
}
context.Fields.Remove(fld);
}
for (int indx = efFieldGroup.FieldGroupsContractTypesMAPs.Count() - 1; indx >= 0; indx--)
{
TopContractsEntities.FieldGroupsContractTypesMAP map = efFieldGroup.FieldGroupsContractTypesMAPs.ElementAt(indx);
context.FieldGroupsContractTypesMAPs.Remove(map);
}
for (int indx = efFieldGroup.FieldGroupsRolesMAPs.Count() - 1; indx >= 0; indx--)
{
TopContractsEntities.FieldGroupsRolesMAP map = efFieldGroup.FieldGroupsRolesMAPs.ElementAt(indx);
context.FieldGroupsRolesMAPs.Remove(map);
}
context.FieldGroups.Remove(efFieldGroup);
}
}
}
if (!populateMapDictionary)
{
context.SaveChanges();
}
else
{
ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
objectContext.DetectChanges();
objectContext.SaveChanges(SaveOptions.None); //This will fill the IDs with new values, needed for the next part...
bool structuralChangeOccurred = false; // flag raised when a structural change is occurred.
//bool informationalChange = false; // flag raised when a change other than structure is occurred.
long nonStructuralChanges = 0;
foreach (var changedEntry in context.ChangeTracker.Entries())
{
if (changedEntry.State == System.Data.EntityState.Added && changedEntry.Entity is TopContractsEntities.Field)
{
if (changedEntry.CurrentValues["ExternalID"] != null)
{
string externalId = changedEntry.CurrentValues["ExternalID"].ToString();
if (externalId.IndexOf(Constants.entityFieldsDivider) >= 0)
{
string id = externalId.Substring(externalId.IndexOf(Constants.entityFieldsDivider));
id = id.Replace(Constants.entityFieldsDivider, "");
int originalFieldID = Convert.ToInt32(id);
EntityFieldIDsMap.Add(originalFieldID, Convert.ToInt64(changedEntry.CurrentValues["FieldID"]));
}
}
if (isCatalogField == false)
structuralChangeOccurred = true;
else
nonStructuralChanges += 1;
}
else if (changedEntry.Entity is TopContractsEntities.Field && changedEntry.State == System.Data.EntityState.Deleted)
{
if (isCatalogField == false)
structuralChangeOccurred = true;
else
nonStructuralChanges += 1;
}
else if (changedEntry.Entity is TopContractsEntities.Field && changedEntry.State == System.Data.EntityState.Modified)
{
if (isCatalogField == false)
nonStructuralChanges += 1;
else
nonStructuralChanges += 1;
}
else if (changedEntry.Entity is TopContractsEntities.FieldsLNG && changedEntry.State == System.Data.EntityState.Modified)
nonStructuralChanges += 1;
else if (changedEntry.Entity is TopContractsEntities.FieldGroup && changedEntry.State == System.Data.EntityState.Added)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroup && changedEntry.State == System.Data.EntityState.Deleted)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroup && changedEntry.State == System.Data.EntityState.Modified)
nonStructuralChanges += 1;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsLNG && changedEntry.State == System.Data.EntityState.Modified)
nonStructuralChanges += 1;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsContractTypesMAP && changedEntry.State == System.Data.EntityState.Added)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsContractTypesMAP && changedEntry.State == System.Data.EntityState.Deleted)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsRolesMAP && changedEntry.State == System.Data.EntityState.Added)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsRolesMAP && changedEntry.State == System.Data.EntityState.Deleted)
structuralChangeOccurred = true;
else if (changedEntry.Entity is TopContractsEntities.FieldGroupsRolesMAP && changedEntry.State == System.Data.EntityState.Modified)
structuralChangeOccurred = true;
}
objectContext.AcceptAllChanges();
//if (isCatalogField && structuralChangeOccurred == false)
//{
// foreach (long fieldId in addedFieldIDs)
// {
// if(structuralChangeOccurred==false)
// }
//}
TopContractsDAL10.CachedData.ClearCachedData(); // To clear cached data of Fields Lng.
ApplicationCachedData.reInitCacheData(); // To re-initialize server side cache.
if (structuralChangeOccurred)
ApplicationCachedData.UpdateContractStructureCacheTicks();
else
if (nonStructuralChanges > 0)
if (isCatalogField)
ApplicationCachedData.UpdateCatalogCacheTicks();
else
ApplicationCachedData.UpdateContractDisplayCacheTicks();
}
//long ContractTypeContractsID = ConfigurationProvider.Default.ContractTypeContracts.ContractTypeContractsID;
long ContractTypeContractsID = Utilities.contractTypeContractsID; // Code implemented by Viplav on 17 june 2013 for remove webconfig concept
foreach (TopContractsEntities.FieldGroup efFldGrp in context.FieldGroups.Where(fgrp => fgrp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll || fgrp.FieldGroupsContractTypesMAPs.Any(cTypeMap => cTypeMap.ContractType.ParentContractTypeID == ContractTypeContractsID) == true))
{
List<long> contractIDs = new List<long>();
List<long?> recordcounters = new List<long?>();
if (efFldGrp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll)
{
foreach (TopContractsEntities.Field efFld in efFldGrp.Fields)
foreach (TopContractsEntities.Contract contract in context.Contracts.Where(c => c.ContractType.ParentContractTypeID == ContractTypeContractsID && c.ContractFields.Any(cf => cf.FieldID == efFld.FieldID) == false))
{
if (efFld.FieldType == (int)FieldTypes.EntityLink)
{
foreach (TopContractsEntities.ContractTypesFieldsToCreateDefault contDef in context.ContractTypesFieldsToCreateDefaults.Where(c => c.ContractTypeID == efFld.LinkedEntityID))
{
/* change this check */
if (contract.ContractFields.Any(cf => cf.FieldID == efFld.FieldID && cf.FieldGroupID == efFldGrp.FieldGroupID && cf.CatalogFieldID == contDef.FieldID) == false)
{
recordcounters = contract.ContractFields.Where(fg => fg.FieldGroupID == efFldGrp.FieldGroupID).Select(c => c.RecordCounter).Distinct().ToList();
TopContractsEntities.Field efDefFld = context.Fields.Where(defld => defld.FieldID == contDef.FieldID).SingleOrDefault();
if (recordcounters.Count != 0)
{
foreach (long? recordcounter in recordcounters)
{
//**************Code Commented by Viplav on 3 mat 2013 for resolving the issue of save undefined text in contract fields**********
//if ((efFld.FieldType == (int)FieldTypes.Autonumber && recordcounter > 0) || efFld.FieldGroup.SingleRecord == true)
//{
// CreateCounterforNewField(context, checkMax, efFld, contract, recordcounter);
//}
//else
//{
//*****************************************************************************************
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
CatalogFieldID = efDefFld.FieldID,
FieldValue = (efDefFld.FieldType == (int)FieldTypes.ListSingle && efDefFld.FieldListItems.Count > 0 && efDefFld.UseFirstAsDefault == true ? efDefFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = (recordcounter == null ? Convert.ToInt64(RecordCounter.Default) : recordcounter)
});
//}
}
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
CatalogFieldID = efDefFld.FieldID,
FieldValue = (efDefFld.FieldType == (int)FieldTypes.ListSingle && efDefFld.FieldListItems.Count > 0 && efDefFld.UseFirstAsDefault == true ? efDefFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = Convert.ToInt64(RecordCounter.Default)
});
}
}
}
}
else
{
recordcounters = contract.ContractFields.Where(fg => fg.FieldGroupID == efFldGrp.FieldGroupID).Select(c => c.RecordCounter).Distinct().ToList();
if (recordcounters.Count != 0)
{
foreach (long? recordcounter in recordcounters)
{
if ((efFld.FieldType == (int)FieldTypes.Autonumber && recordcounter > 0) || (efFld.FieldGroup.SingleRecord == true && efFld.FieldType == (int)FieldTypes.Autonumber))
{
CreateCounterforNewField(context, checkMax, efFld, contract, recordcounter);
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
FieldValue = (efFld.FieldType == (int)FieldTypes.ListSingle && efFld.FieldListItems.Count > 0 && efFld.UseFirstAsDefault == true ? efFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = (recordcounter == null ? Convert.ToInt64(RecordCounter.Default) : recordcounter)
});
}
}
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
FieldValue = (efFld.FieldType == (int)FieldTypes.ListSingle && efFld.FieldListItems.Count > 0 && efFld.UseFirstAsDefault == true ? efFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = Convert.ToInt64(RecordCounter.Default)
});
}
}
}
}
else
{
if (efFldGrp.FieldGroupsContractTypesMAPs != null)
foreach (FieldGroupsContractTypesMAP fgcMap in efFldGrp.FieldGroupsContractTypesMAPs)
{
if (context.Contracts.Any(c => c.ContractTypeID == fgcMap.ContractTypeID))
contractIDs.AddRange(context.Contracts.Where(c => c.ContractTypeID == fgcMap.ContractTypeID && c.ContractType.ParentContractTypeID == ContractTypeContractsID).Select(c => c.ContractID));
}
if (contractIDs.Count > 0)
foreach (TopContractsEntities.Field efFld in efFldGrp.Fields)
{
foreach (TopContractsEntities.Contract contract in context.Contracts.Where(c => (c.ContractFields.Any(cf => cf.FieldID == efFld.FieldID) == false) && c.ContractType.ParentContractTypeID == ContractTypeContractsID))
{
if (contractIDs.Contains(contract.ContractID))
{
if (efFld.FieldType == (int)FieldTypes.EntityLink)
{
foreach (TopContractsEntities.ContractTypesFieldsToCreateDefault contDef in context.ContractTypesFieldsToCreateDefaults.Where(c => c.ContractTypeID == efFld.LinkedEntityID))
{
/* change this check */
if (contract.ContractFields.Any(cf => cf.FieldID == efFld.FieldID && cf.FieldGroupID == efFldGrp.FieldGroupID && cf.CatalogFieldID == contDef.FieldID) == false)
{
recordcounters = contract.ContractFields.Where(fg => fg.FieldGroupID == efFldGrp.FieldGroupID).Select(c => c.RecordCounter).Distinct().ToList();
if (recordcounters.Count != 0)
{
foreach (long? recordcounter in recordcounters)
{
//**************Code Commented by Viplav on 3 mat 2013 for resolving the issue of save undefined text in contract fields**********
//if ((efFld.FieldType == (int)FieldTypes.Autonumber && recordcounter > 0) || efFld.FieldGroup.SingleRecord == true)
//{
// CreateCounterforNewField(context, checkMax, efFld, contract, recordcounter);
//}
//else
//{
//********************************************************************************
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
CatalogFieldID = contDef.Field.FieldID,
FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.FieldListItems.Count > 0 && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = (recordcounter == null ? Convert.ToInt64(RecordCounter.Default) : recordcounter)
});
//}
}
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
CatalogFieldID = contDef.Field.FieldID,
FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.FieldListItems.Count > 0 && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = Convert.ToInt64(RecordCounter.Default)
});
}
}
}
}
else
{
recordcounters = contract.ContractFields.Where(fg => fg.FieldGroupID == efFldGrp.FieldGroupID).Select(c => c.RecordCounter).Distinct().ToList();
if (recordcounters.Count != 0)
{
foreach (long? recordcounter in recordcounters)
{
if ((efFld.FieldType == (int)FieldTypes.Autonumber && recordcounter > 0) || (efFld.FieldGroup.SingleRecord == true && efFld.FieldType == (int)FieldTypes.Autonumber))
{
CreateCounterforNewField(context, checkMax, efFld, contract, recordcounter);
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
FieldValue = (efFld.FieldType == (int)FieldTypes.ListSingle && efFld.FieldListItems.Count > 0 && efFld.UseFirstAsDefault == true ? efFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = (recordcounter == null ? Convert.ToInt64(RecordCounter.Default) : recordcounter)
});
}
}
}
else
{
contract.ContractFields.Add(new TopContractsEntities.ContractField()
{
FieldGroupID = efFld.FieldGroupID,
FieldID = efFld.FieldID,
FieldValue = (efFld.FieldType == (int)FieldTypes.ListSingle && efFld.FieldListItems.Count > 0 && efFld.UseFirstAsDefault == true ? efFld.FieldListItems.First().FieldListItemID.ToString() : ""),
RecordCounter = Convert.ToInt64(RecordCounter.Default)
});
}
}
}
}
}
contractIDs = new List<long>();
bool noMap = false;
if (efFldGrp.FieldGroupsContractTypesMAPs == null)
noMap = true;
else
if (efFldGrp.FieldGroupsContractTypesMAPs.Count == 0)
noMap = true;
if (noMap)
contractIDs.AddRange(context.Contracts.Select(c => c.ContractID));
else
foreach (TopContractsEntities.Contract contract in context.Contracts.Where(c => c.ContractType.ParentContractTypeID == ContractTypeContractsID))
{
if (efFldGrp.FieldGroupsContractTypesMAPs.Any(fgcMap => fgcMap.ContractTypeID == contract.ContractTypeID) == false)
contractIDs.Add(contract.ContractID);
}
DateTime updateDate = DateTime.Now;
if (contractIDs.Count > 0)
foreach (int cId in contractIDs)
{
TopContractsEntities.Contract contract = context.Contracts.Single(c => c.ContractID == cId);
if (contract.ContractFields.Any(cf => cf.FieldGroupID == efFldGrp.FieldGroupID))
{
List<TopContractsEntities.ContractField> cFields = contract.ContractFields.Where(cf => cf.FieldGroupID == efFldGrp.FieldGroupID).ToList();
for (int indx = cFields.Count - 1; indx >= 0; indx--)
{
TopContractsEntities.ContractField efCtrctFld = cFields[indx];
context.ContractFields.Remove(efCtrctFld);
if (AuditChanges)
{
HistManager histManager = new HistManager();
histManager.AuditFieldRemoval(updateDate, UpdatingUserID, efCtrctFld);
}
}
}
}
}
}
return context.SaveChanges();
//return -1;
}
public int Save(SaveSearchs Data, int UpdatingUserID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.SaveSearch efSaveSearch = null;
TopContractsEntities.SearchResultsContract efSaveContracts = null;
foreach (TopContractsDAL10.DasboardTables.SaveSearch svSearch in Data.Entries)
{
if (svSearch.New)
{
efSaveSearch = new TopContractsEntities.SaveSearch();
}
else
{
efSaveSearch = context.SaveSearches.Where(c => c.SearchId == svSearch.ID).SingleOrDefault();
}
if (svSearch.Deleted == false)
{
efSaveSearch.DisplayOrder = svSearch.DisplayOrder;
efSaveSearch.Description = svSearch.Description;
efSaveSearch.Name = svSearch.Name;
efSaveSearch.ExternalID = svSearch.ExternalID;
efSaveSearch.SearchQuery = svSearch.SearchQuery;
efSaveSearch.Inactive = svSearch.Inactive;
efSaveSearch.Locked = svSearch.Locked;
efSaveSearch.OrganizationIdentifier = this.organizationIdentifier;
foreach (TopContractsDAL10.DasboardTables.SearchResultsContract svContracts in svSearch.searchResultsContracts.Entries)
{
if (svContracts.New)
{
efSaveContracts = new TopContractsEntities.SearchResultsContract();
}
else
{
efSaveContracts = context.SearchResultsContracts.Where(c => c.SearchContractId == svContracts.ID).SingleOrDefault();
}
if (svContracts.Deleted == false)
{
efSaveContracts.SearchId = svContracts.SearchId;
efSaveContracts.ContractId = svContracts.ContractId;
}
if ((svContracts.New == true && svContracts.Deleted == false) || (svContracts.New == false && svContracts.Deleted == true))
{
if (svContracts.New)
efSaveSearch.SearchResultsContracts.Add(efSaveContracts);
else
{
if (svContracts.Deleted && efSaveContracts != null)
{
efSaveSearch.SearchResultsContracts.Remove(efSaveContracts);
context.SearchResultsContracts.Remove(efSaveContracts);
}
}
}
}
}
if (svSearch.New)
{
context.SaveSearches.Add(efSaveSearch);
}
else
{
if (svSearch.Deleted && efSaveSearch != null)
{
foreach (TopContractsDAL10.DasboardTables.SearchResultsContract svContracts in svSearch.searchResultsContracts.Entries)
{
efSaveContracts = context.SearchResultsContracts.Where(c => c.SearchContractId == svContracts.ID).SingleOrDefault();
context.SearchResultsContracts.Remove(efSaveContracts);
}
context.SaveSearches.Remove(efSaveSearch);
}
}
}
bool updateSavedSearchDetails = false;
foreach (var entry in context.ChangeTracker.Entries())
{
if (entry.State == System.Data.EntityState.Added || entry.State == System.Data.EntityState.Modified)
{
updateSavedSearchDetails = true;
}
}
if (updateSavedSearchDetails)
foreach (var entry in context.ChangeTracker.Entries())
{
if (entry.Entity is TopContractsEntities.SaveSearch && (entry.State == EntityState.Added || entry.State == EntityState.Modified))
{
((TopContractsEntities.SaveSearch)entry.Entity).UpdateDate = DateTime.Now;
((TopContractsEntities.SaveSearch)entry.Entity).UpdateUserID = UpdatingUserID;
}
}
return context.SaveChanges();
}
/// <summary>
/// Get Role ID of user in contract (role of user in the authorized entities list)
/// </summary>
/// <param action="ContractID">Contract ID</param>
/// <param action="UserID">User ID</param>
/// <returns>Role ID</returns>
public static long GetRoleIDInContract(long ContractID, long UserID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
try
{
long roleID =
context.Contracts.Where(c => c.ContractID == ContractID).SingleOrDefault().ContractUsers.Where(u => u.UserID == UserID).SingleOrDefault().Role.RoleID;
return roleID;
}
catch (Exception ex)
{
return -1;
}
}
/// <summary>
/// find shared groups (groups shared by all contracts)
/// </summary>
/// <param name="contractIds">List of contract IDs - this list will be checked, so that only groups
/// shared by all these contracts will be returned</param>
/// <param name="fieldGroupIDsToUse">
/// Optional parameter; If provided, it acts as a filter - any field groups not contained in this filter, will
/// be removed from the shared group list. Example, if shared group was found to contain IDs 1,5,7,8 and the
/// filter is 2,5,8 then only 5,8 will be returned
/// </param>
/// <returns></returns>
public static List<long> GetAllSharedGroupIDs(List<long> contractIds, List<long> fieldGroupIDsToUse = null)
{
List<long> sharedGroupIDs = new List<long>();
if (fieldGroupIDsToUse != null)
if (fieldGroupIDsToUse.Count == 0)
return sharedGroupIDs;
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
//First find all groups of all contracts (distinct); example, if contract A contains 1,2,3
//and contract B contains 2,3,7, then the list is 1,2,3,7
sharedGroupIDs = context.ContractFields.Where(cf => contractIds.Contains(cf.ContractID)).Select(cf => cf.FieldGroupID).Distinct().ToList();
//now remove any group missing from at least one of the contracts (or from the filter list)
for (int indx = sharedGroupIDs.Count - 1; indx >= 0; indx--)
{
long sharedGroupID = sharedGroupIDs[indx];
bool removed = false;
//If filter exists, and does not contain field-group ID - remove it...
if (fieldGroupIDsToUse != null)
if (fieldGroupIDsToUse.Any(ftu => ftu == sharedGroupID) == false)
{
sharedGroupIDs.RemoveAt(indx);
removed = true;
}
if (removed == false)
foreach (long contractID in contractIds)
{
if (context.ContractFields.Any(cf => cf.ContractID == contractID && cf.FieldGroupID == sharedGroupID) == false)
{
sharedGroupIDs.RemoveAt(indx);
break;
}
}
}
return sharedGroupIDs;
}
/// <summary>
/// This function will check that contract is Normal contract or catalog type.
/// </summary>
/// <param name="ContractID"></param>
/// <returns></returns>
public static bool IsCatalogTypeContract(long ContractID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
long ContractTypeContractsID = TopContractsDAL10.Utilities.contractTypeContractsID;
long cTypeId = context.Contracts.FirstOrDefault(t => t.ContractID == ContractID).ContractTypeID;
return context.ContractTypes.Any(pct => (pct.ParentContractTypeID != ContractTypeContractsID || pct.ParentContractTypeID == null) && pct.ContractTypeID == cTypeId);
}
/// <summary>
/// This constructor is only used to fetch an existing contract, and not for creating a new one.
/// </summary>
/// <param action="ContractID">ID of contract to fetch</param>
/// <param action="CultureIdentifier">Culture Identifier used for the selection of Fields and Field-Groups
/// names in the appropriate language.</param>
/// <param name="paging">Object of ContractSectionPaging class to provide page sizes of various contract sections.</param>
/// <param action="UserId">UserID may be passed to set the read-only value of RoleName of that user
/// in the selected contract</param>
public Contract(long ContractID, string CultureIdentifier, ContractSectionPaging paging, long? UserId = null, ContractSections Content = ContractSections.All, List<long> GroupIDs = null)
{
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Commencing CTOR for ContractID {0}, UserId {1}, Content {2}", ContractID, UserId, Content.ToString());
//ErrorDTO Error = null;
//try
//{
Deleted = false;
Properties = new ContractProperties();
initLists();
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Lists initialized");
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Contract efContract = context.Contracts.Where(u => u.ContractID == ContractID).SingleOrDefault();
this.ID = efContract.ContractID;
this.Properties.initDataFields(efContract);
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Data Fields initialized");
this.Properties.initPrivateFields(efContract, CultureIdentifier, UserId);
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Private Fields initialized");
if ((Content & ContractSections.Events) == ContractSections.Events)
{
this.ContractActivities.AddRange(efContract.ContractActivities.Select(ca => new ContractActivity(ca, CultureIdentifier)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Events added for ContractSections.Events");
}
if ((Content & ContractSections.Alerts) == ContractSections.Alerts)
{
this.ContractTodos.AddRange(efContract.ContractTodos.Select(ca => new ContractTodo(ca, CultureIdentifier)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Alerts added for ContractSections.Alerts");
}
if ((Content & ContractSections.AuthorizedEntities) == ContractSections.AuthorizedEntities)
{
bool showAllUser = false;
long? MaxPageSizeUsers = null;
if (paging.UsersPaging.PagingBehaviour == PagingParameter.DontPage)
showAllUser = true;
else if (paging.UsersPaging.PagingBehaviour == PagingParameter.OverrideDatabaseValues)
MaxPageSizeUsers = paging.UsersPaging.PagingValue;
else
MaxPageSizeUsers = GetPagingValueFromDB(efContract.OrganizationIdentifier, ContractSections.AuthorizedEntities);
if (showAllUser == true || MaxPageSizeUsers == null)
this.ContractUsers.AddRange(efContract.ContractUsers.Select(ca => new ContractUser(ca, CultureIdentifier)));
else
this.ContractUsers.AddRange(GetContractUsersByPaging(ContractID, CultureIdentifier, Convert.ToInt64(MaxPageSizeUsers)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Users added for ContractSections.AuthorizedEntities");
}
if ((Content & ContractSections.Applications) == ContractSections.Applications)
{
this.ContractApplications.AddRange(efContract.ContractApplications.Select(ca => new ContractApplication(ca)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Applications added for ContractSections.Applications");
}
if ((Content & ContractSections.Fields) == ContractSections.Fields)
{
//Code Commented By Viplav for implement sorting related to (DisplayOrder / Alphabatically)
//long groupID = 0;
//foreach (TopContractsEntities.ContractField field in efContract.ContractFields.OrderBy(fl => fl.FieldGroupID))
//{
// if (field.FieldGroupID != groupID)
// {
// groupID = field.FieldGroupID;
// this.ContractFieldGroups.Add(new ContractFieldGroup(field, CultureIdentifier));
// }
//}
//Viplav
//------------Boaz 25-July-2013-------------
//If this "contract" is a catalog record, and it is now fetched as part of a process of
//fetching many such catalog records of the same type, then groupFields collection should
//be initialized only once...
List<FieldGroup> efFieldGroups = null;
if (Contract.initializingCatalogRecords == false || Contract.efFieldGroupsForContractInit == null)
{
efFieldGroups = new List<FieldGroup>();
//if (efContract.ContractFields.Any(fg => fg.FieldGroup.DisplayOrder == null))
//{
// efFieldGroups = efContract.ContractFields.Select(fg => fg.FieldGroup).Distinct().OrderBy(fgl => fgl.FieldGroupsLNGs.FirstOrDefault(cul => cul.CultureId.Trim() == CultureIdentifier).DescShort).ToList();
//}
//else
//{
// efFieldGroups = efContract.ContractFields.Select(fg => fg.FieldGroup).Distinct().OrderBy(fgd => fgd.DisplayOrder).ToList();
//}
//List<ContractTypeFieldGroupsMap> groupsMap = new List<ContractTypeFieldGroupsMap>();
//groupsMap = ApplicationCachedData.ContractTypeFieldGroupsMap;
if (efContract.ContractType.ParentContractTypeID == Utilities.contractTypeContractsID)
{
if (ApplicationCachedData.ContractTypeFieldGroupsMap.Any(ct => ct.ContractTypeID == efContract.ContractTypeID))
{
Dictionary<string, List<FieldGroup>> FieldGroupsByLang = ApplicationCachedData.ContractTypeFieldGroupsMap.Single(ct => ct.ContractTypeID == efContract.ContractTypeID).FieldGroupsByLang;
if (FieldGroupsByLang.Count() > 0)
if (FieldGroupsByLang.Any(lng => lng.Key == CultureIdentifier))
efFieldGroups = FieldGroupsByLang.Single(lng => lng.Key == CultureIdentifier).Value;
}
}
else
{
if (ApplicationCachedData.CatalogFieldGroupsMap.Any(ct => ct.ContractTypeID == efContract.ContractTypeID))
{
Dictionary<string, List<FieldGroup>> FieldGroupsByLang = ApplicationCachedData.CatalogFieldGroupsMap.Single(ct => ct.ContractTypeID == efContract.ContractTypeID).FieldGroupsByLang;
if (FieldGroupsByLang.Count() > 0)
if (FieldGroupsByLang.Any(lng => lng.Key == CultureIdentifier))
efFieldGroups = FieldGroupsByLang.Single(lng => lng.Key == CultureIdentifier).Value;
}
}
Contract.efFieldGroupsForContractInit = efFieldGroups;
}
else
efFieldGroups = Contract.efFieldGroupsForContractInit;
// if list of GroupIDs is not null
if (GroupIDs != null)
{
if (GroupIDs.Count() > 0)
{
// retrieve only those fieldgroups which are requested.
efFieldGroups = efFieldGroups.Where(fg => GroupIDs.Contains(fg.FieldGroupID)).ToList();
}
}
foreach (FieldGroup fieldgroup in efFieldGroups)
{
this.ContractFieldGroups.Add(new ContractFieldGroup(context, fieldgroup, CultureIdentifier, ContractID));
}
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Fields added for ContractSections.Fields");
}
if ((Content & ContractSections.Documents) == ContractSections.Documents)
{
this.ContractDocs.AddRange(efContract.ContractDocs.Select(ca => new ContractDoc(ca)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Documents added for ContractSections.Documents");
}
if ((Content & ContractSections.Gallery) == ContractSections.Gallery)
{
this.ContractGalleries.AddRange(efContract.ContractGalleries.OrderByDescending(cg => cg.CreatedOn).Select(cg => new ContractGallery(cg)));
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Galleries added for ContractSections.Gallery");
}
if ((Content & ContractSections.ChildContract) == ContractSections.ChildContract) // Condition Implemented for getting only neccessary Data by Viplav on 14 May 2013
{
this.ChildContracts = new ChildContract(ref context, efContract).ChildContracts;
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Child Contracts collection initialized");
}
if ((Content & ContractSections.ParantContract) == ContractSections.ParantContract) // Condition Implemented for getting only neccessary Data by Viplav on 14 May 2013
{
if (efContract.ParentContractID != null)
{
//this.ParentContract = new Contract((long)efContract.ParentContractID, CultureIdentifier, UserId, Content);
this.ParentContract = new Contract((long)efContract.ParentContractID, CultureIdentifier, paging, UserId, Content); // Kai Cohen - Modified code to pass paging parameters.
Logger.WriteGeneralVerbose("Contract class - CTOR 2", "Parent Contracts initialized");
}
}
}
/// <summary>
/// get last value of ID field of contracts-table
/// </summary>
/// <returns></returns>
public static long LastContractID()
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
return context.Contracts.Max(c => c.ContractID);
}
public static TopContractsDAL10.ContractApplication GetApplications(long contractID, int ApplicationID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Contract efContract = context.Contracts.Where(u => u.ContractID == contractID).SingleOrDefault();
if (efContract == null)
throw new ExceptionDataContractReadNoSuchContract();
TopContractsEntities.ContractApplication efConApp = new TopContractsEntities.ContractApplication();
efConApp.ApplicationID = ApplicationID;
efConApp.ContractID = contractID;
efConApp.Application = context.Applications.SingleOrDefault(ca => ca.ApplicationID == ApplicationID);
efConApp.Contract = context.Contracts.SingleOrDefault(ca => ca.ContractID == contractID);
TopContractsDAL10.ContractApplication cApp = new ContractApplication(efConApp);
return cApp;
}
/// <summary>
/// UpdateCopyContractDocDirectory (Update the directory action according to new contract)
/// </summary>
/// <param action="NewContractID">Id of NewContractID performing the update</param>
/// <returns></returns>
public static void UpdateCopyContractDocDirectory(long NewContractID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
foreach (var Contractdoc in context.ContractDocs.Where(cdoc => cdoc.ContractID == NewContractID).ToList())
{
Contractdoc.FileDirectory = Storage.DocsPath(NewContractID);
}
context.SaveChanges();
}
//end code
/// <summary>--Added by Viplav Bhateja (28/02/2013)
/// Used to get only common field group (this functionality is used for copy contract when user change his current contract type))
/// </summary>
/// <param action="ContractTypeID">Contract TypeID is used to get contractfieldgroup according to this contract type.</param>
/// <param action="ContractToSave">Contract to save is an existing loaded contract so we can inplement a functionality to add only common field group.</param>
/// <param action="CultureIdentifier">Culture Identifier used for the selection of Fields and Field-Groups
/// names in the appropriate language.</param>
/// <returns></returns>
public static List<int> getCommonContractFieldGroup(int parentContractTypeID, int childContractTypeID, string CultureIdentifier)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
//long ContractTypeContractsID = ConfigurationProvider.Default.ContractTypeContracts.ContractTypeContractsID;
long ContractTypeContractsID = Utilities.contractTypeContractsID; // Code implemented by Viplav on 17 june 2013 for remove webconfig concept
TopContractsDAL10.SystemTables.FieldGroups fieldGroups = new SystemTables.FieldGroups();
List<int> parentFieldGroupIDs = new List<int>();
List<int> childFieldGroupIDs = new List<int>();
List<int> commonFieldGroupIDs = new List<int>();
if (context.ContractTypes.Any(ct => ct.ParentContractTypeID == ContractTypeContractsID && ct.ContractTypeID == parentContractTypeID))
fieldGroups = SystemTables.FieldGroups.Get(false, false, true, CultureIdentifier);
else
fieldGroups = SystemTables.FieldGroups.GetWithoutParentContractTypeID(false, false, true, CultureIdentifier);
foreach (TopContractsDAL10.SystemTables.FieldGroup fieldGroup in fieldGroups.Entries)
{
if (context.ContractTypes.Any(ct => ct.ParentContractTypeID == ContractTypeContractsID && ct.ContractTypeID == parentContractTypeID))
{
if (fieldGroup.ContractTypeIDsVisible.Any(ct => ct == parentContractTypeID) || fieldGroup.VisibleToAllContractTypes)
parentFieldGroupIDs.Add((int)fieldGroup.ID);
}
}
foreach (TopContractsDAL10.SystemTables.FieldGroup fieldGroup in fieldGroups.Entries)
{
if (context.ContractTypes.Any(ct => ct.ParentContractTypeID == ContractTypeContractsID && ct.ContractTypeID == childContractTypeID))
{
if (fieldGroup.ContractTypeIDsVisible.Any(ct => ct == childContractTypeID) || fieldGroup.VisibleToAllContractTypes)
childFieldGroupIDs.Add((int)fieldGroup.ID);
}
}
foreach (int cfg in childFieldGroupIDs)
{
if (parentFieldGroupIDs.Any(ctrgroup => ctrgroup == cfg))
{
commonFieldGroupIDs.Add(cfg);
}
}
return commonFieldGroupIDs;
}
public static void UpdateGalleryImageFilePath(long galleryId, string FilePath)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
foreach (TopContractsEntities.ContractGalleryImage efContractGalleryImage in context.ContractGalleryImages.Where(cd => cd.GalleryID == galleryId).ToList())
{
efContractGalleryImage.FileDirectory = FilePath;
}
context.SaveChanges();
}
//Get the Contracts with Contract type ID --Added by deepak dhamija (28/02/2013)
public static List<long> getContractsbyContractTypeID(long contractTypeID)
{
List<Contract> contracts = new List<Contract>();
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
List<long> contractIDs = context.Contracts.Where(cnts => cnts.ContractTypeID == contractTypeID).Select(cnt => cnt.ContractID).ToList();
return contractIDs;
}
/// <summary>
/// Gets all users of a contract.
/// </summary>
/// <param name="ContractID">ID of contract</param>
/// <param name="CultureIdentifier">Culture identifier to be used to retrieve users information</param>
/// <returns>List of TopContractsDAL10.ContractUser objects.</returns>
public List<ContractUser> GetAllContractUsers(long ContractID, string CultureIdentifier)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
List<ContractUser> users = new List<ContractUser>();
if (context.Contracts.Any(cu => cu.ContractID == ContractID))
{
TopContractsEntities.Contract efContract = context.Contracts.SingleOrDefault(cu => cu.ContractID == ContractID);
users.AddRange(efContract.ContractUsers.Select(ca => new ContractUser(ca, CultureIdentifier)));
}
return users;
}
/// <summary>
/// Get a list of users linked to the contract (authorized entities)
/// </summary>
/// <param action="ContractID">Contract ID</param>
/// <returns>List of TopContractsEntities.ContractUser objects</returns>
public static List<TopContractsEntities.ContractUser> GetContractUsers(long ContractID)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
return (context.Contracts.Where(c => c.ContractID == ContractID).SingleOrDefault().ContractUsers.ToList());
}
/// <summary>
/// Gets contract users by a specific page size.
/// </summary>
/// <param name="ContractID">ID of the contract.</param>
/// <param name="CultureIdentifier">CultureID in which names are required.</param>
/// <param name="MaxPageSizeUsers">Number of users to be required.</param>
/// <returns>List of TopContractsDAL10.ContractUser objects.</returns>
public List<ContractUser> GetContractUsersByPaging(long ContractID, string CultureIdentifier, long MaxPageSizeUsers)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
List<ContractUser> contractUsers = new List<ContractUser>();
if (context.Contracts.Any(ct => ct.ContractID == ContractID))
{
TopContractsEntities.Contract efContract = context.Contracts.SingleOrDefault(ct => ct.ContractID == ContractID);
if (efContract.ContractUsers.Count(ct => ct.ContractID == ContractID) <= MaxPageSizeUsers)
{
contractUsers = efContract.ContractUsers.Where(ct => ct.ContractID == ContractID).Select(ca => new ContractUser(ca, CultureIdentifier)).ToList();
}
else
{
List<TopContractsEntities.ContractUser> usersWithEditPermissions = new List<TopContractsEntities.ContractUser>();
List<TopContractsEntities.ContractUser> usersWithViewPermissions = new List<TopContractsEntities.ContractUser>();
bool roleCanEdit = false;
//bool roleCanEditGroups = false;
//List<ContractUser> contractUsersToFilter = context.ContractUsers.Where(ct => ct.ContractID == ContractID).Select(ca => new ContractUser(ca, CultureIdentifier)).ToList();
List<TopContractsEntities.ContractUser> efContractUsers = efContract.ContractUsers.Where(ct => ct.ContractID == ContractID).ToList();
List<TopContractsEntities.FieldGroup> efFieldGroups = context.ContractFields.Where(cf => cf.ContractID == ContractID).Select(fg => fg.FieldGroup).Distinct().ToList();
foreach (TopContractsEntities.ContractUser efContractUser in efContractUsers)
{
roleCanEdit = (efContractUser.Role.EditProperties == true || efContractUser.Role.EditActivities == true ||
efContractUser.Role.AddActivities == true || efContractUser.Role.DeleteActivities == true ||
efContractUser.Role.EditTodos == true || efContractUser.Role.AddTodos == true || efContractUser.Role.DeleteTodos == true ||
efContractUser.Role.EditAuth == true || efContractUser.Role.EditDocs == true ||
efContractUser.Role.AddDocs == true || efContractUser.Role.DeleteDocs == true ||
efContractUser.Role.EditApps == true || efContractUser.Role.EditGallery == true ||
efContractUser.Role.AddGallery == true || efContractUser.Role.DeleteGallery == true);
roleCanEdit = roleCanEdit || RolePermittedToEditContractFields(efFieldGroups, efContractUser.Role);
if (roleCanEdit == true)
usersWithEditPermissions.Add(efContractUser);
else
usersWithViewPermissions.Add(efContractUser);
}
if (usersWithEditPermissions.Count >= MaxPageSizeUsers)
contractUsers.AddRange(usersWithEditPermissions.Take((int)MaxPageSizeUsers).Select(ca => new ContractUser(ca, CultureIdentifier)).ToList());
else
{
contractUsers.AddRange(usersWithEditPermissions.Select(ca => new ContractUser(ca, CultureIdentifier)).ToList());
//int usersToAdd = (int)MaxPageSizeUsers - usersWithEditPermissions.Count();
contractUsers.AddRange(usersWithViewPermissions.Take((int)MaxPageSizeUsers - usersWithEditPermissions.Count()).Select(ca => new ContractUser(ca, CultureIdentifier)).ToList());
}
}
}
return contractUsers;
}
/// <summary>
/// getEntityContracts Method used to get all contracts according to contracttypeID for entities records
/// </summary>
/// <param action="contractTypeID">contractTypeID is used to retreive contracts from DB</param>
/// <param action="CultureIdentifier">CultureIdentifier is used to get data according to current culture</param>
/// <returns>List of contracts</returns>
public static List<TopContractsDAL10.Contract> getEntityContracts(long contractTypeID, string CultureIdentifier, Guid OrganizationIdentifier, int UserID)
{
List<Contract> contracts = new List<Contract>();
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
List<long> contractIDs = context.Contracts.Where(cnts => cnts.ContractTypeID == contractTypeID).Select(cnt => cnt.ContractID).ToList();
if (contractIDs.Count > 0)
{
//This flag is used to inform the contract initialization process that many "contracts" (catalog records)
//of the same type are now being created, so it needs to avoid re-creating structures which are common
//to all these "contracts"...
initializingCatalogRecords = true;
TopContractsDAL10.Contract.efFieldGroupsForContractInit = null;
foreach (long contractID in contractIDs)
{
//TopContractsDAL10.Contract conts = new Contract(contractID, CultureIdentifier, null, ContractSections.Fields);
ContractSectionPaging dontPage = new ContractSectionPaging().SetDontPage();
TopContractsDAL10.Contract conts = new Contract(contractID, CultureIdentifier, dontPage, null, ContractSections.Fields); // Kai Cohen - Modified code to pass paging parameters. -1 tells the method to bring all records.
contracts.Add(conts);
}
initializingCatalogRecords = false;
}
else
{
TopContractsDAL10.Contract conts = new Contract(OrganizationIdentifier, "", contractTypeID, 1, UserID, CultureIdentifier); // 1 is used for default status ID (HardCoded) and "" foe Contractname
contracts.Add(conts);
}
return contracts;
}
/// <summary>
/// Save contract (delete or add according to Deleted and New properties)
/// </summary>
/// <param action="UpdatingUserID">Id of user performing the update</param>
/// <param action="AuditChanges">Audit changes of update</param>
/// <returns>The ID of the contract saved, or 0 if contract was deleted, or -1 to indicate a failure to save contract</returns>
public long Save(int UpdatingUserID, bool AuditChanges)
{
Logger.WriteGeneralVerbose("Contract class - save", "updating ContractActivity of {0}", this.ID);
//Logger.Write(LogCategory.General, (this.New ? "Creating new " : (this.Deleted ? "Deleting " : "Updating ")) + "contract", "contract ID " + this.ID.ToString(), System.Diagnostics.TraceEventType.Information);
DateTime updateDate = DateTime.Now;
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Contract efContract = null;
if (this.New)
{
efContract = new TopContractsEntities.Contract();
efContract.ContractUpdateDetail = new ContractUpdateDetail();
//long ContractTypeContractsID = ConfigurationProvider.Default.ContractTypeContracts.ContractTypeContractsID;
long ContractTypeContractsID = Utilities.contractTypeContractsID; // Code implemented by Viplav on 17 june 2013 for remove webconfig concept
if (context.FieldGroups.Count(grp => grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll) > 0)
//foreach (FieldGroup grp in context.FieldGroups.Where(
// grp => (grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll || grp.FieldGroupsContractTypesMAPs.Any(cTypeMap => cTypeMap.ContractType.ParentContractTypeID == ContractTypeContractsID) == true) && grp.Inactive == false)) //Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fieldsgroup
foreach (FieldGroup grp in context.FieldGroups.Where(
grp => (grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToAll && grp.Inactive == false)).ToList()) // Jan 31, 2013 - Need to be tested properly as now loop is running for VisibleToAll efFieldGroupsForContractInit
{
foreach (Field fld in grp.Fields.Where(grpf => grpf.Inactive == false)) //Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fields
{
if (fld.FieldType == (int)FieldTypes.EntityLink)
{
foreach (TopContractsEntities.ContractTypesFieldsToCreateDefault contDef in context.ContractTypesFieldsToCreateDefaults.Where(c => c.ContractTypeID == fld.LinkedEntityID))
{
//efContract.ContractFields.Add(new TopContractsEntities.ContractField() { FieldGroupID = grp.EntryIdentifier, FieldID = contDef.FieldID, FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
efContract.ContractFields.Add(new TopContractsEntities.ContractField() { OrganizationIdentifier = this.Properties.OrganizationIdentifier, FieldGroupID = grp.EntryIdentifier, FieldID = fld.FieldID, CatalogFieldID = contDef.FieldID, FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
}
}
else
efContract.ContractFields.Add(new TopContractsEntities.ContractField() { OrganizationIdentifier = this.Properties.OrganizationIdentifier, FieldGroupID = grp.EntryIdentifier, FieldID = fld.EntryIdentifier, FieldValue = (fld.FieldType == (int)FieldTypes.ListSingle && fld.UseFirstAsDefault == true ? fld.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
}
}
if (context.FieldGroups.Count(grp => grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && grp.FieldGroupsContractTypesMAPs.Any(mp => mp.ContractTypeID == this.Properties.ContractTypeID)) > 0)
foreach (FieldGroup grp in context.FieldGroups.Where(grp => grp.ContractTypeVisibility == (byte)FieldGroupContractTypeVisibility.VisibleToTypes && grp.Inactive == false && grp.FieldGroupsContractTypesMAPs.Any(mp => mp.ContractTypeID == this.Properties.ContractTypeID)))//Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fieldsgroup
foreach (Field fld in grp.Fields.Where(grpf => grpf.Inactive == false)) //Viplav - 16-Oct-2012 // Implemented inactive condition for getting only active fields
{
if (fld.FieldType == (int)FieldTypes.EntityLink)
{
foreach (TopContractsEntities.ContractTypesFieldsToCreateDefault contDef in context.ContractTypesFieldsToCreateDefaults.Where(c => c.ContractTypeID == fld.LinkedEntityID))
{
//efContract.ContractFields.Add(new TopContractsEntities.ContractField() { FieldGroupID = grp.EntryIdentifier, FieldID = contDef.FieldID, FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
efContract.ContractFields.Add(new TopContractsEntities.ContractField() { OrganizationIdentifier = this.Properties.OrganizationIdentifier, FieldGroupID = grp.EntryIdentifier, FieldID = fld.FieldID, CatalogFieldID = contDef.FieldID, FieldValue = (contDef.Field.FieldType == (int)FieldTypes.ListSingle && contDef.Field.UseFirstAsDefault == true ? contDef.Field.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
}
}
else
efContract.ContractFields.Add(new TopContractsEntities.ContractField() { OrganizationIdentifier = this.Properties.OrganizationIdentifier, FieldGroupID = grp.EntryIdentifier, FieldID = fld.EntryIdentifier, FieldValue = (fld.FieldType == (int)FieldTypes.ListSingle && fld.UseFirstAsDefault == true ? fld.FieldListItems.ElementAt(0).FieldListItemID.ToString() : ""), RecordCounter = Convert.ToInt64(RecordCounter.Default) });
}
}
else
{
efContract = context.Contracts.Where(u => u.ContractID == this.ID).SingleOrDefault();
}
if (this.Deleted)
{
#region DELETING RELATED ENTITIES -----------------------------------------------------------------------------
//For some unknown reason, eliminating the if-count>0 from before each of the foreach(s), throws an "object not set" exception even though alerts exist!
context.ContractUpdateDetails.Remove(context.ContractUpdateDetails.Single(entry => entry.ContractID == this.ID));
if (context.ContractApplications.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractApplication efContractApplication in context.ContractApplications.Where(entry => entry.ContractID == this.ID))
context.ContractApplications.Remove(efContractApplication);
if (context.ContractActivities.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractActivity efContractActivity in context.ContractActivities.Where(entry => entry.ContractID == this.ID))
{
context.ContractActivities.Remove(efContractActivity);
}
if (context.ContractDocs.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractDoc efContractDoc in context.ContractDocs.Where(entry => entry.ContractID == this.ID))
context.ContractDocs.Remove(efContractDoc);
if (context.ContractGalleries.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractGallery efContractGallery in context.ContractGalleries.Where(entry => entry.ContractID == this.ID))
{
if (efContractGallery.ContractGalleryImages != null && efContractGallery.ContractGalleryImages.Count() > 0)
{
foreach (TopContractsEntities.ContractGalleryImage image in efContractGallery.ContractGalleryImages.ToList())
{
context.ContractGalleryImages.Remove(image);
}
}
context.ContractGalleries.Remove(efContractGallery);
}
if (context.ContractFields.Count(entry => entry.ContractID == this.ID) > 0)
foreach (TopContractsEntities.ContractField efContractField in context.ContractFields.Where(entry => entry.ContractID == this.ID))
context.ContractFields.Remove(efContractField);
if (context.ContractTodos.Count(entry => entry.ContractID == this.ID) > 0)
{
foreach (TopContractsEntities.ContractTodo efContractTodo in context.ContractTodos.Where(entry => entry.ContractID == this.ID))
{
if (efContractTodo.ContractTodoRecipients != null)
for (int indx = efContractTodo.ContractTodoRecipients.Count - 1; indx >= 0; indx--)
context.ContractTodoRecipients.Remove(efContractTodo.ContractTodoRecipients.ElementAt(indx));
if (efContractTodo.ContractTodoUnits != null)
for (int indx = efContractTodo.ContractTodoUnits.Count - 1; indx >= 0; indx--)
context.ContractTodoUnits.Remove(efContractTodo.ContractTodoUnits.ElementAt(indx));
if (efContractTodo.DoneTodos != null)
for (int indx = efContractTodo.DoneTodos.Count - 1; indx >= 0; indx--)
context.DoneTodos.Remove(efContractTodo.DoneTodos.ElementAt(indx));
context.ContractTodos.Remove(efContractTodo);
}
}
foreach (TopContractsEntities.ContractUser efContractUser in context.ContractUsers.Where(entry => entry.ContractID == this.ID))
context.ContractUsers.Remove(efContractUser);
#endregion
context.Contracts.Remove(efContract);
}
if (this.New)
{
updateEfContract(ref efContract, ref context);
context.Contracts.Add(efContract);
}
if (this.New == false & this.Deleted == false)
{
updateEfContract(ref efContract, ref context);
}
//Boaz-1 (8-Aug-2012) ------------------------------------------------------
//All Todos which are linked to new events, should be made their "children" in the EF so that the foreign
//key values will be automatically generated when saving to the DB
foreach (TopContractsEntities.ContractTodo todo in efContract.ContractTodos.Where(td => td.ActivityID < 0))
{
efContract.ContractActivities.SingleOrDefault(ca => ca.ActivityID == todo.ActivityID).ContractTodos.Add(todo);
}
// code to remove images from context for a deleted gallery
foreach (ContractGallery gallery in this.ContractGalleries)
{
if (gallery.Deleted)
{
foreach (TopContractsEntities.ContractGalleryImage galleryImage in context.ContractGalleryImages.Where(g => g.GalleryID == gallery.EntryId))
context.ContractGalleryImages.Remove(galleryImage);
}
// code to remove a deleted gallery image
if (!gallery.New)
{
foreach (ContractGalleryImage image in gallery.Images)
{
if (image.Deleted)
{
if (context.ContractGalleryImages.Any(g => g.GalleryImageID == image.EntryId))
{
TopContractsEntities.ContractGalleryImage galleryImage = context.ContractGalleryImages.SingleOrDefault(g => g.GalleryImageID == image.EntryId);
context.ContractGalleryImages.Remove(galleryImage);
}
}
}
}
}
bool updateContractUpdateDetails = false;
if (this.Deleted == false)
{
//If any of the entities related to the contract has changed, the Update-Date of the contract record itself should be updated...
foreach (var entry in context.ChangeTracker.Entries())
{
//Boaz 7-Aug-2012
//if (entry.State == System.Data.EntityState.Added || entry.State == System.Data.EntityState.Modified && !(entry.Entity is EFContractRelatedEntryWithUpdate))
if (entry.State == System.Data.EntityState.Added || entry.State == System.Data.EntityState.Modified || entry.State == System.Data.EntityState.Deleted)
{
updateContractUpdateDetails = true;
}
}
if (updateContractUpdateDetails)
foreach (var entry in context.ChangeTracker.Entries())
{
//Boaz 7-Aug-2012
//If any changed was made to a record in any table (entities related to the contract) which has
//UpdateDate and UpdateUserID fields, these fields are updated to reflect the change.
//These fields are NOT handled by the individual classes committing the changes to the
//database - they are handled centrally here to cut-down on the code
if (entry.Entity is EFContractRelatedEntryWithUpdate && entry.State != EntityState.Unchanged)
//if (entry.Entity is EFContractRelatedEntryWithUpdate)
{
((EFContractRelatedEntryWithUpdate)entry.Entity).UpdatingDate = updateDate;
((EFContractRelatedEntryWithUpdate)entry.Entity).UpdatingUserID = UpdatingUserID;
}
if (entry.Entity is TopContractsEntities.ContractDoc && entry.State == EntityState.Deleted)
{
TopContractsEntities.User Userdetail = context.Users.Where(usr => usr.UserID == UpdatingUserID).SingleOrDefault();
if (Userdetail != null)
{
if (context.Roles.Where(rol => rol.RoleID == Userdetail.DefaultRoleID).SingleOrDefault().DeleteDocs == false)
entry.State = EntityState.Unchanged;
}
}
if (entry.Entity is TopContractsEntities.ContractActivity && entry.State == EntityState.Deleted)
{
TopContractsEntities.User Userdetail = context.Users.Where(usr => usr.UserID == UpdatingUserID).SingleOrDefault();
if (Userdetail != null)
{
if (context.Roles.Where(rol => rol.RoleID == Userdetail.DefaultRoleID).SingleOrDefault().DeleteActivities == false)
entry.State = EntityState.Unchanged;
else //********** Code Implemented for remove contract event with all associated Alerts,AlertsRecipiets & AlertsDone by Viplav on 20-Nov-2013**********************************
{
List<TopContractsEntities.ContractTodo> contToDos = context.ContractTodos.Where(tod => tod.ActivityID == ((TopContractsEntities.ContractActivity)entry.Entity).ActivityID).ToList();
foreach (TopContractsEntities.ContractTodo cntToDos in contToDos)
{
foreach (TopContractsEntities.ContractTodoRecipient cntToDosRec in context.ContractTodoRecipients.Where(tod => tod.TodoID == cntToDos.TodoID))
context.ContractTodoRecipients.Remove(cntToDosRec);
foreach (TopContractsEntities.DoneTodo doneToDos in context.DoneTodos.Where(todo => todo.OriginalTodoID == cntToDos.TodoID))
context.DoneTodos.Remove(doneToDos);
context.ContractTodos.Remove(cntToDos);
}
}//*****************************************************************************************************************************************************************************
}
}
}
}
if (updateContractUpdateDetails)
{
efContract.ContractUpdateDetail.UpdateDate = updateDate;
efContract.ContractUpdateDetail.UpdateUserID = UpdatingUserID;
}
//We want to keep tracking the changes after calling SaveChanges, for the purpose of auditing
ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
objectContext.DetectChanges();
try
{
//Using SaveOptions.None to keep change-tracking... Requires objectContext.DetectChanges() before and objectContext.AcceptAllChanges() after...
int rowsAffected = objectContext.SaveChanges(SaveOptions.None);
}
catch (System.Data.UpdateException updEx)
{
if (updEx.InnerException != null)
if (updEx.InnerException.Message.Contains("DELETE statement conflicted with the REFERENCE constraint") &&
updEx.InnerException.Message.Contains("FK_ContractTodos_ContractActivities"))
{
// Logger.Write(updEx, System.Diagnostics.TraceEventType.Warning);
Logger.WriteGeneralWarning("Contract - Save()", "An attempt has been made to delete an Event With an Alert, in contract #{0}, by user #{1}", this.ID, UpdatingUserID);
throw new ExceptionDataContractSaveDeleteEventWithAlert();
}
else if (updEx.InnerException.Message.Contains("DELETE statement conflicted with the REFERENCE constraint") &&
updEx.InnerException.Message.Contains("FK_ContractFields_ContractActivities"))
{
Logger.WriteGeneralWarning("Contract - Save()", "An attempt has been made to delete an Event linked to an event type field, in contract #{0}, by user #{1}", this.ID, UpdatingUserID);
throw new ExceptionDataContractSaveDeleteEventWithEventTypeFields();
}
else if (updEx.InnerException.Message.Contains("FK_Contracts_Contracts") &&
updEx.InnerException.Message.Contains("ParentContractID"))
{
Logger.WriteGeneralWarning("Contract - Save()", "An attempt has been made to delete contract #{0}, by user #{1}, when this contract is a parenty of another contract", this.ID, UpdatingUserID);
throw new ExceptionDataContractDeleteDeleteContractWithChild();
}
else if (updEx.InnerException.Message.Contains("DELETE statement conflicted with the REFERENCE constraint") &&
updEx.InnerException.Message.Contains("FK_ContractFields_ContractDocs"))
{
Logger.WriteGeneralWarning("Contract - Save()", "Contract - Save()", "An attempt has been made to delete a document linked to a document-type field, in contract #{0}, by user #{1}", this.ID, UpdatingUserID);
throw new ExceptionDataContractSaveDeleteDocsWithDocumentTypeFields();
}
else
{
// Logger.Write(updEx, System.Diagnostics.TraceEventType.Error);
Logger.WriteExceptionError("Contract - Save()", updEx, "The attempt to save contract #{0}, by user #{1}, has failed", this.ID, UpdatingUserID);
throw updEx;
}
}
//Boaz-1 (8-Aug-2012) -------------------------------------------------------
//#region Setting the connection between new activities and their related new todos
//if (this.Deleted == false)
//{
// foreach (var newActivity in context.ChangeTracker.Entries())
// {
// if (newActivity.State == System.Data.EntityState.Added && newActivity.Entity is TopContractsEntities.ContractActivity)
// {
// foreach (var newTodo in context.ChangeTracker.Entries())
// {
// if (newTodo.State == System.Data.EntityState.Added && newTodo.Entity is TopContractsEntities.ContractTodo)
// {
// if ((newTodo.Entity as TopContractsEntities.ContractTodo).ActivityID == (newActivity.Entity as TopContractsEntities.ContractActivity).ActivityID)
// {
// (newActivity.Entity as TopContractsEntities.ContractActivity).ContractTodos.Add((newTodo.Entity as TopContractsEntities.ContractTodo));
// }
// }
// }
// }
// }
//}
//#endregion
//TopContractsEntities.ContractTodo todoToChange = null;
if (AuditChanges)
{
HistManager histManager = new HistManager();
int recordsWrittenToHistory = histManager.AuditChanges(updateDate, UpdatingUserID, this.New, this.Deleted, context.ChangeTracker.Entries().Where(e => e.State != System.Data.EntityState.Unchanged || e.Entity is TopContractsEntities.Contract));
}
objectContext.AcceptAllChanges();
long contractIdSaved = -1; //will indicate failure, if no number is set
foreach (var entry in context.ChangeTracker.Entries())
{
Logger.Write("entering the loop - for context.ChangeTracker.Entries()", System.Diagnostics.TraceEventType.Verbose);
if (entry.Entity is TopContractsEntities.Contract)
{
contractIdSaved = ((TopContractsEntities.Contract)entry.Entity).ContractID;
}
if (entry.Entity is TopContractsEntities.ContractDoc)
{
TopContractsEntities.ContractDoc efDoc = entry.Entity as TopContractsEntities.ContractDoc;
TopContractsDAL10.ContractDoc doc = this.ContractDocs.SingleOrDefault(d => d.FileName == efDoc.FileName);
if (doc != null)
{
if (doc.New)
{
doc.EntryId = efDoc.DocumentID; //This is done especially for the process of file copying...
}
}
}
if (entry.Entity is TopContractsEntities.ContractGallery)
{
TopContractsEntities.ContractGallery efGallery = entry.Entity as TopContractsEntities.ContractGallery;
foreach (TopContractsDAL10.ContractGallery gallery in this.ContractGalleries.Where(g => g.GalleryName == efGallery.GalleryName).ToList())
{
if (gallery.New)
{
gallery.EntryId = efGallery.GalleryID; //This is done especially for the process of file copying...
}
}
}
}
if (this.Deleted)
return 0;
return contractIdSaved;
}
public int Save(Statuses Data)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.Status efStatus = null;
foreach (TopContractsDAL10.SystemTables.Status Status in Data.Entries)
{
if (Status.New)
{
efStatus = new TopContractsEntities.Status();
}
else
{
efStatus = context.Statuses.Where(c => c.StatusID == Status.ID).SingleOrDefault();
}
if (Status.Deleted == false)
efStatus.InitCommonFields(efStatus, Status, efStatus.StatusesLNGs, this.organizationIdentifier);
if (Status.New)
context.Statuses.Add(efStatus);
else
{
if (Status.Deleted && efStatus != null)
{
efStatus.DeleteLanguageEntries(efStatus, context.StatusesLNGs, efStatus.StatusesLNGs);
//for (int indx = efStatus.StatusesLNGs.Count() - 1; indx >= 0; indx--)
//{
// TopContractsEntities.StatusesLNG lng = efStatus.StatusesLNGs.ElementAt(indx);
// context.StatusesLNGs.Remove(lng);
//}
context.Statuses.Remove(efStatus);
}
}
}
return context.SaveChanges();
}