public ResultStatus LoadESigDetails(
EmployeeMaint employeeMaint,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
return(this.LoadESigDetails(employeeMaint, (EmployeeMaint_LoadESigDetails_Parameters)null, request, out result));
}
private void CreateActivity(int classId, long?refNoteID, string typeCode, Action <object> initializeHandler)
{
var graphType = EPActivityPrimaryGraphAttribute.GetGraphType(classId);
if (!PXAccess.VerifyRights(graphType))
{
throw new AccessViolationException(CR.Messages.FormNoAccessRightsMessage(graphType));
}
var cache = CreateInstanceCache <EPActivity>(graphType);
if (cache != null)
{
var owner = EmployeeMaint.GetCurrentEmployeeID(cache.Graph);
var activity = (EPActivity)cache.CreateCopy(cache.Insert());
activity.ClassID = classId;
activity.RefNoteID = refNoteID;
if (!string.IsNullOrEmpty(typeCode))
{
activity.Type = typeCode;
}
activity.Owner = owner;
if (initializeHandler != null)
{
initializeHandler(activity);
}
cache.Update(activity);
PXRedirectHelper.TryRedirect(cache.Graph, PXRedirectHelper.WindowMode.NewWindow);
}
}
public ResultStatus GetWIPMsgs(
EmployeeMaint employeeMaint,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
return(this.GetWIPMsgs(employeeMaint, (EmployeeMaint_Parameters)null, request, out result));
}
public ResultStatus Delete(
EmployeeMaint employeeMaint,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
return(this.Delete(employeeMaint, (EmployeeMaint_Parameters)null, request, out result));
}
public new IEnumerable NewContact(PXAdapter adapter)
{
if (this.BAccountAccessor.Cache.GetStatus(this.BAccountAccessor.Current) != PXEntryStatus.Inserted)
{
EmployeeMaint graph = PXGraph.CreateInstance <EmployeeMaint>();
EPEmployee cont = new EPEmployee();
cont.RouteEmails = true;
cont.ParentBAccountID = this.BAccountAccessor.Current.BAccountID;
try
{
cont = (EPEmployee)graph.Employee.Insert(cont);
}
catch (PXFieldProcessingException ex)
{
if (graph.Employee.Cache.GetBqlField(ex.FieldName) == typeof(EPEmployee.parentBAccountID))
{
throw new PXSetPropertyException(Messages.BranchNotEnoughRights, this.BAccountAccessor.Current.AcctCD);
}
throw;
}
throw new PXRedirectRequiredException(graph, CR.Messages.ContactMaint);
}
return(adapter.Get());
}
public virtual void ViewEmployee()
{
EmployeeMaint graph = CreateInstance <EmployeeMaint>();
graph.Employee.Current = graph.Employee.Search <EPEmployee.userID>(Members.Current.UserID);
throw new PXRedirectRequiredException(graph, "ViewEmployee");
}
/// <summary>
/// Links the Smartsheet user information to the Acumatica's Employee
/// </summary>
/// <param name="projectEntryGraph">Project graph</param>
/// <param name="smartsheetClient">Smartsheet SDK Client</param>
public void CreateEmployeesAcuUserSS(ProjectEntry projectEntryGraph, SmartsheetClient smartsheetClient)
{
User userRow = new User();
AccessUsers accessUsersGraph = PXGraph.CreateInstance <AccessUsers>();
AccessUsersSSIExt graphExtended = accessUsersGraph.GetExtension <AccessUsersSSIExt>();
try
{
EmployeeMaint employeeMaintGraph = PXGraph.CreateInstance <EmployeeMaint>();
foreach (EPEmployeeContract filter in projectEntryGraph.EmployeeContract.Select())
{
EPEmployee ePEmployeeRecord = employeeMaintGraph.Employee.Current = employeeMaintGraph.Employee.Search <EPEmployee.bAccountID>(filter.EmployeeID);
if (ePEmployeeRecord == null)
{
return;
}
EPEmployeeSSExt ePEmployeeExtRecord = PXCache <EPEmployee> .GetExtension <EPEmployeeSSExt>(ePEmployeeRecord);
if (String.IsNullOrEmpty(Convert.ToString(ePEmployeeExtRecord.UsrSSUserid)))
{
userRow = graphExtended.CreateSmartsheetUser(filter.EmployeeID, smartsheetClient);
if (userRow != null)
{
PXCache <EPUsersListSS> usersListCache = employeeMaintGraph.Caches <EPUsersListSS>();
EPUsersListSS epUsersListSSRow = UserSSList.Select().Where(x => ((EPUsersListSS)x).Ssuserid == userRow.Id).FirstOrDefault();
if (epUsersListSSRow == null)
{
EPUsersListSS usersListSSRow = (EPUsersListSS)usersListCache.Insert(new EPUsersListSS
{
Ssuserid = userRow.Id,
FirstName = userRow.FirstName,
LastName = userRow.LastName,
Email = userRow.Email,
BAccountID = filter.EmployeeID
});
}
else
{
epUsersListSSRow.BAccountID = filter.EmployeeID;
epUsersListSSRow.FirstName = userRow.FirstName;
epUsersListSSRow.LastName = userRow.LastName;
epUsersListSSRow.Email = userRow.Email;
usersListCache.Update(epUsersListSSRow);
}
employeeMaintGraph.Persist();
PXDatabase.Update <EPEmployee>(new PXDataFieldRestrict <EPEmployee.bAccountID>(filter.EmployeeID),
new PXDataFieldAssign <EPEmployeeSSExt.usrSSUserID>(userRow.Id));
}
}
}
}
catch (Exception ex)
{
throw new PXException(ex.Message);
}
}
public virtual void ViewEmployee()
{
if (Members.Current.UserID != null)
{
EmployeeMaint graph = CreateInstance <EmployeeMaint>();
graph.Employee.Current = graph.Employee.Search <EPEmployee.userID>(Members.Current.UserID);
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.NewWindow);
}
}
public EmployeeMaintMethod(
EmployeeMaint Cdo,
EmployeeMaintMethods Method,
EmployeeMaint_Parameters Parameters)
{
this.Cdo = Cdo;
this.ServiceMethod = Method;
this.Parameters = Parameters;
}
public new IEnumerable ViewContact(PXAdapter adapter)
{
if (this.Employees.Current != null && this.BAccountAccessor.Cache.GetStatus(this.BAccountAccessor.Current) != PXEntryStatus.Inserted)
{
EPEmployee current = this.Employees.Current;
EmployeeMaint graph = PXGraph.CreateInstance <EmployeeMaint>();
graph.Employee.Current = graph.Employee.Search <EPEmployee.bAccountID>(current.BAccountID);
throw new PXRedirectRequiredException(graph, CR.Messages.ContactMaint);
}
return(adapter.Get());
}
public new IEnumerable NewContact(PXAdapter adapter)
{
if (this.BAccountAccessor.Cache.GetStatus(this.BAccountAccessor.Current) != PXEntryStatus.Inserted)
{
EmployeeMaint graph = PXGraph.CreateInstance <EmployeeMaint>();
EPEmployee cont = new EPEmployee();
cont.RouteEmails = true;
cont.ParentBAccountID = this.BAccountAccessor.Current.BAccountID;
cont = (EPEmployee)graph.Employee.Insert(cont);
throw new PXRedirectRequiredException(graph, CR.Messages.ContactMaint);
}
return(adapter.Get());
}
public ResultStatus GetEnvironment(
EmployeeMaint cdo,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
result = (EmployeeMaint_Result)null;
try
{
return(((IEmployeeMaintService)this._Channel).GetEnvironment(this._UserProfile, cdo, request, out result));
}
catch (Exception ex)
{
return(this.OnThrowException(ex));
}
}
public new IEnumerable ViewContact(PXAdapter adapter)
{
if (this.EmployeesAccessor.Current != null && this.BAccountAccessor.Cache.GetStatus(this.BAccountAccessor.Current) != PXEntryStatus.Inserted)
{
EPEmployee current = this.EmployeesAccessor.Current;
EmployeeMaint graph = PXGraph.CreateInstance <EmployeeMaint>();
if ((graph.Employee.Current = graph.Employee.Search <EPEmployee.bAccountID>(current.BAccountID)) == null)
{
throw new PXSetPropertyException(Messages.YouDoNotHaveSufficientAccessRightsToViewOrModifyAnEmployee,
PXUIFieldAttribute.GetItemName(BAccount.Cache),
BAccountAccessor.Current.AcctCD);
}
throw new PXRedirectRequiredException(graph, CR.Messages.ContactMaint);
}
return(adapter.Get());
}
public ResultStatus AddDataTransaction(EmployeeMaint cdo)
{
this.OnBeforeCall(nameof(AddDataTransaction), (DCObject)cdo, (Parameters)null, (Request)null);
ResultStatus res;
try
{
res = !this._IsTransactionOpened ? this.GetAddDataTransactionException() : this.AddMethod((Method) new EmployeeMaintMethod(cdo, EmployeeMaintMethods.AddDataTransaction, (EmployeeMaint_Parameters)null));
}
catch (Exception ex)
{
res = this.OnThrowException(ex);
}
if (res.IsSuccess)
{
Result result;
this.OnAfterCall(nameof(AddDataTransaction), res, (DCObject)cdo, (Parameters)null, (Request)null, result);
}
return(res);
}
public virtual IEnumerable ViewCustomer(PXAdapter adapter)
{
BAccount account = PXSelect <BAccount, Where <BAccount.bAccountID, Equal <Current <PMTran.bAccountID> > > > .Select(this);
if (account != null)
{
if (account.Type == BAccountType.CustomerType || account.Type == BAccountType.CombinedType)
{
CustomerMaint graph = CreateInstance <CustomerMaint>();
graph.BAccount.Current = PXSelect <Customer, Where <Customer.bAccountID, Equal <Current <PMTran.bAccountID> > > > .Select(this);
throw new PXRedirectRequiredException(graph, true, "")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
else if (account.Type == BAccountType.VendorType)
{
VendorMaint graph = CreateInstance <VendorMaint>();
graph.BAccount.Current = PXSelect <VendorR, Where <VendorR.bAccountID, Equal <Current <PMTran.bAccountID> > > > .Select(this);
throw new PXRedirectRequiredException(graph, true, "")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
else if (account.Type == BAccountType.EmployeeType || account.Type == BAccountType.EmpCombinedType)
{
EmployeeMaint graph = CreateInstance <EmployeeMaint>();
graph.Employee.Current = PXSelect <EPEmployee, Where <EPEmployee.bAccountID, Equal <Current <PMTran.bAccountID> > > > .Select(this);
throw new PXRedirectRequiredException(graph, true, "")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
}
return(adapter.Get());
}
public ResultStatus ExecuteTransaction(
EmployeeMaint cdo,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
result = (EmployeeMaint_Result)null;
this.OnBeforeCall(nameof(ExecuteTransaction), (DCObject)cdo, (Parameters)null, (Request)request);
ResultStatus res;
try
{
res = !this._IsTransactionOpened ? ((IEmployeeMaintService)this._Channel).ExecuteTransaction(this._UserProfile, cdo, request, out result) : this.AddMethod((Method) new EmployeeMaintMethod(cdo, EmployeeMaintMethods.ExecuteTransaction, (EmployeeMaint_Parameters)null));
}
catch (Exception ex)
{
res = this.OnThrowException(ex);
}
if (res.IsSuccess)
{
this.OnAfterCall(nameof(ExecuteTransaction), res, (DCObject)cdo, (Parameters)null, (Request)request, (Result)result);
}
return(res);
}
public ResultStatus Delete(
EmployeeMaint employeeMaint,
EmployeeMaint_Parameters parameters,
EmployeeMaint_Request request,
out EmployeeMaint_Result result)
{
result = (EmployeeMaint_Result)null;
this.OnBeforeCall(nameof(Delete), (DCObject)employeeMaint, (Parameters)parameters, (Request)request);
ResultStatus res;
try
{
res = !this._IsTransactionOpened ? ((IEmployeeMaintService)this._Channel).Delete(this._UserProfile, employeeMaint, parameters, request, out result) : this.AddMethod((Method) new EmployeeMaintMethod(employeeMaint, EmployeeMaintMethods.Delete, parameters));
}
catch (Exception ex)
{
res = this.OnThrowException(ex);
}
if (res.IsSuccess)
{
this.OnAfterCall(nameof(Delete), res, (DCObject)employeeMaint, (Parameters)parameters, (Request)request, (Result)result);
}
return(res);
}
public new IEnumerable NewContact(PXAdapter adapter)
{
if (this.BAccountAccessor.Cache.GetStatus(this.BAccountAccessor.Current) != PXEntryStatus.Inserted)
{
EmployeeMaint graph = CreateInstance <EmployeeMaint>();
try
{
int?ParentBAccountID = BaccountIDForNewEmployee();
graph.Employee.Insert(new EPEmployee
{
RouteEmails = true,
ParentBAccountID = ParentBAccountID
});
graph.Employee.Cache.IsDirty = false;
graph.Caches <RedirectEmployeeParameters>().Insert(new RedirectEmployeeParameters
{
RouteEmails = true,
ParentBAccountID = ParentBAccountID
});
}
catch (PXFieldProcessingException ex)
{
if (graph.Employee.Cache.GetBqlField(ex.FieldName) == typeof(EPEmployee.parentBAccountID))
{
throw new PXSetPropertyException(Messages.YouDoNotHaveSufficientAccessRightsToViewOrModifyAnEmployee,
PXUIFieldAttribute.GetItemName(BAccount.Cache),
BAccountAccessor.Current.AcctCD);
}
throw;
}
PXRedirectHelper.TryRedirect(graph, PXRedirectHelper.WindowMode.NewWindow);
}
return(adapter.Get());
}
private void CreateActivity(int classId, Guid?refNoteID, string typeCode, Guid?owner, PXRedirectHelper.WindowMode windowMode = PXRedirectHelper.WindowMode.NewWindow)
{
var graphType = CRActivityPrimaryGraphAttribute.GetGraphType(classId);
if (!PXAccess.VerifyRights(graphType))
{
throw new AccessViolationException(CR.Messages.FormNoAccessRightsMessage(graphType));
}
CRActivity activity = null;
var cache = CreateInstanceCache <CRActivity>(graphType);
if (cache == null)
{
return;
}
if (owner == null)
{
owner = EmployeeMaint.GetCurrentEmployeeID(cache.Graph);
}
Action <object> initializeHandler = delegate(object act1)
{
var act = act1 as CRActivity;
if (act == null)
{
return;
}
act.ClassID = classId;
act.RefNoteID = refNoteID;
if (!string.IsNullOrEmpty(typeCode))
{
act.Type = typeCode;
}
act.OwnerID = owner;
};
EntityHelper helper = new EntityHelper(cache.Graph);
var type = helper.GetEntityRowType(refNoteID);
var entity = helper.GetEntityRow(type, refNoteID);
Type entityGraphType = null;
if (type != null)
{
PXPrimaryGraphAttribute.FindPrimaryGraph(cache.Graph.Caches[type], ref entity, out entityGraphType);
}
if (entityGraphType != null)
{
PXGraph entry = PXGraph.CreateInstance(entityGraphType);
PXCache <CRActivity> activityCache = entry.Caches[typeof(CRActivity)] as PXCache <CRActivity>;
if (activityCache != null)
{
entry.Views[entry.PrimaryView].Cache.Current = entity;
activity = (CRActivity)activityCache.CreateInstance();
if (initializeHandler != null)
{
initializeHandler(activity);
}
activity = activityCache.InitNewRow(activity);
}
}
if (activity == null)
{
activity = (CRActivity)cache.CreateInstance();
initializeHandler(activity);
activity = ((PXCache <CRActivity>)cache).InitNewRow(activity);
}
cache.Update(activity);
PXRedirectHelper.TryRedirect(cache.Graph, windowMode);
}
public ResultStatus NewCopy(EmployeeMaint employeeMaint)
{
return(this.NewCopy(employeeMaint, (EmployeeMaint_Parameters)null, (EmployeeMaint_Request)null, out EmployeeMaint_Result _));
}
public ResultStatus AddRoles(EmployeeMaint employeeMaint)
{
return(this.AddRoles(employeeMaint, (EmployeeMaint_Parameters)null, (EmployeeMaint_Request)null, out EmployeeMaint_Result _));
}
public ResultStatus UnFreeze(EmployeeMaint employeeMaint)
{
return(this.UnFreeze(employeeMaint, (EmployeeMaint_Parameters)null, (EmployeeMaint_Request)null, out EmployeeMaint_Result _));
}
public ResultStatus ExecuteTransaction(EmployeeMaint cdo)
{
return(this.ExecuteTransaction(cdo, (EmployeeMaint_Request)null, out EmployeeMaint_Result _));
}
