public UserParametersResponse Post(UserParameters request)
{
if (request.UserParameter.Id > 0)
{
Bm2s.Data.Common.BLL.Parameter.UserParameter item = Datas.Instance.DataStorage.UserParameters[request.UserParameter.Id];
item.bValue = request.UserParameter.bValue;
item.dValue = request.UserParameter.dValue;
item.fValue = Convert.ToDouble(request.UserParameter.fValue);
item.iValue = request.UserParameter.iValue;
item.sValue = request.UserParameter.sValue;
Datas.Instance.DataStorage.UserParameters[request.UserParameter.Id] = item;
}
else
{
Bm2s.Data.Common.BLL.Parameter.UserParameter item = new Data.Common.BLL.Parameter.UserParameter()
{
bValue = request.UserParameter.bValue,
dValue = request.UserParameter.dValue,
fValue = Convert.ToDouble(request.UserParameter.fValue),
iValue = request.UserParameter.iValue,
sValue = request.UserParameter.sValue,
};
Datas.Instance.DataStorage.UserParameters.Add(item);
request.UserParameter.Id = item.Id;
}
UserParametersResponse response = new UserParametersResponse();
response.UserParameters.Add(request.UserParameter);
return response;
}
public UserParametersResponse Delete(UserParameters request)
{
Bm2s.Data.Common.BLL.Parameter.Parameter item = Datas.Instance.DataStorage.Parameters[request.UserParameter.Id];
Datas.Instance.DataStorage.Parameters.Remove(item);
UserParametersResponse response = new UserParametersResponse();
response.UserParameters.Add(request.UserParameter);
return response;
}
public UserParametersResponse Get(UserParameters request)
{
UserParametersResponse response = new UserParametersResponse();
List<Bm2s.Data.Common.BLL.Parameter.UserParameter> items = new List<Data.Common.BLL.Parameter.UserParameter>();
if (!request.Ids.Any())
{
items.AddRange(Datas.Instance.DataStorage.UserParameters.Where(item =>
(request.ParameterId == 0 || item.ParameterId == request.ParameterId)
));
}
else
{
items.AddRange(Datas.Instance.DataStorage.UserParameters.Where(item => request.Ids.Contains(item.Id)));
}
var collection = (from item in items
select new Bm2s.Poco.Common.Parameter.UserParameter()
{
bValue = item.bValue,
dValue = item.dValue,
fValue = Convert.ToDecimal(item.fValue),
Id = item.Id,
iValue = item.iValue,
sValue = item.sValue
}).AsQueryable().OrderBy(request.Order, !request.DescendingOrder);
response.ItemsCount = collection.Count();
if (request.PageSize > 0)
{
response.UserParameters.AddRange(collection.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize));
}
else
{
response.UserParameters.AddRange(collection);
}
try
{
response.PagesCount = collection.Count() / response.UserParameters.Count + (collection.Count() % response.UserParameters.Count > 0 ? 1 : 0);
}
catch
{
response.PagesCount = 1;
}
return response;
}
public async Task <ActionResult> AddUser(UserParameters parameters)
{
var userView = await GetModelFromParameters(parameters);
if (userView.User.FdpUserId.HasValue)
{
return(JsonGetFailure(string.Format("User '{0}' already exists", parameters.CDSId)));
}
userView.User = await DataContext.User.AddUser(Model.User.FromParameters(parameters));
if (userView.User is EmptyUser)
{
return(JsonGetFailure(string.Format("User '{0}' could not be created", parameters.CDSId)));
}
FlushCache(parameters.CDSId);
return(JsonGetSuccess());
}
public async Task <ActionResult> DisableUser(UserParameters parameters)
{
var userView = await GetModelFromParameters(parameters);
if (userView.User is EmptyUser)
{
return(JsonGetFailure(string.Format("User '{0}' does not exist", parameters.CDSId)));
}
userView.User = await DataContext.User.DisableUser(Model.User.FromParameters(parameters));
if (userView.User is EmptyUser)
{
return(JsonGetFailure(string.Format("User '{0}' could not be disabled", parameters.CDSId)));
}
FlushCache(parameters.CDSId);
return(JsonGetSuccess());
}
public async Task <PagedList <SysUser> > GetAllUsersAsync(UserParameters parameters)
{
var query = _userRepository.Query("Role");
if (!string.IsNullOrEmpty(parameters.UserName))
{
var userName = parameters.UserName.ToLowerInvariant();
query = query.Where(x => x.UserName.ToLowerInvariant().Contains(userName));
}
if (!string.IsNullOrEmpty(parameters.RealName))
{
var realName = parameters.RealName.ToLowerInvariant();
query = query.Where(x => x.RealName.ToLowerInvariant().Contains(realName));
}
if (parameters.Status.HasValue)
{
var status = parameters.Status.Value;
query = query.Where(x => x.Status == status);
}
if (!string.IsNullOrEmpty(parameters.CreateTime))
{
var time = parameters.CreateTime.Trim().Split('-');
var start = DateTime.Parse(time[0] + '-' + time[1] + '-' + time[2]);
var end = DateTime.Parse(time[3] + '-' + time[4] + '-' + time[5]);
query = query.Where(x => x.CreateTime >= start && x.CreateTime <= end);
}
//var query = _dbContext.Posts.OrderBy(x => x.Id);
//query = query.OrderBy(x => x.Id);
query = query.ApplySort(parameters.OrderBy, _propertyMappingContainer.Resolve <UserViewModel, SysUser>()); //排序
var count = await query.CountAsync();
var data = await query
.Skip((parameters.PageIndex - 1) *parameters.PageSize)
.Take(parameters.PageIndex * parameters.PageSize)
.ToListAsync();
return(new PagedList <SysUser>(parameters.PageIndex, parameters.PageSize, count, data));
}
/// <summary>
/// Updates the paramters in the assembly.
/// May need to tie in PushParams and Update iLogic Addins
/// </summary>
public void updateAssemblyParams()
{
AssemblyDocument assemblyDoc = (AssemblyDocument)invApp.ActiveDocument;
AssemblyComponentDefinition assemblyDef = assemblyDoc.ComponentDefinition;
Parameters assemblyParameters = assemblyDef.Parameters;
UserParameters assemblyUserParams = assemblyParameters.UserParameters;
UserParameter assemblyUserParam;
#region "User Parameters Update"
assemblyUserParam = assemblyUserParams["length"];
assemblyUserParam.Expression = length + " in";
assemblyUserParam = assemblyUserParams["width"];
assemblyUserParam.Expression = width + " in";
assemblyUserParam = assemblyUserParams["height"];
assemblyUserParam.Expression = height + " in";
assemblyUserParam = assemblyUserParams["frameDia"];
assemblyUserParam.Expression = frameDia + " in";
assemblyUserParam = assemblyUserParams["cwDia"];
assemblyUserParam.Expression = cwDia + " in";
assemblyUserParam = assemblyUserParams["cwSpcX"];
assemblyUserParam.Expression = cwSpcX + " in";
assemblyUserParam = assemblyUserParams["cwSpcZ"];
assemblyUserParam.Expression = cwSpcZ + " in";
assemblyUserParam = assemblyUserParams["midFrameDia"];
assemblyUserParam.Expression = midFrameDia + " in";
assemblyUserParam = assemblyUserParams["midFrameNum"];
assemblyUserParam.Expression = midFrameNum + " ul";
#endregion
invApp.ActiveView.Fit(); // Fit part to view
assemblyDoc.Update2();
assemblyDoc.Save2();
// Release objects
assemblyUserParams = null;
assemblyParameters = null;
assemblyDef = null;
assemblyDoc = null;
}
public PagedList <User> Pagination <T>(UserParameters parameters, Expression <Func <User, bool> > predicate = null)
{
IQueryable <User> result = document.AsQueryable();
if (predicate != null)
{
result = result.Where(predicate);
}
FilterAndSearchQuery(parameters, ref result);
if (parameters.OrderBy == "Id")
{
result.OrderBy(c => c.Id);
}
else
{
result = result.ApplySort(parameters.OrderBy, _propertyMappingService.GetPropertyMappings <User, T>());
}
return(PagedList <User> .Create(result, parameters.Page, parameters.Size));
}
public async Task <ActionResult <IEnumerable <MemberDto> > > GetUsers([FromQuery] UserParameters userParameters)
{
var userGender = await this.unitOfWork.UserRepository.GetUserGender(User.GetUserName());
userParameters.CurrentUserName = User.GetUserName();
if (string.IsNullOrEmpty(userParameters.Gender))
{
userParameters.Gender = userGender == "male" ? "female" : "male";
}
var users = await this.unitOfWork.UserRepository.GetMembersAsync(userParameters);
this.Response.AddPaginationHeader(
users.CurrentPage,
users.PageSize,
users.TotalCount,
users.TotalPages);
return(Ok(users));
}
public HttpResponseMessage AvailablePost([FromBody] UserParameters user)
{
try
{
if (MainObject.MainList.ContainsKey(user.AgentId))
{
CApp mpApp = MainObject.MainList[user.AgentId];
mpApp.BecomeAvailable();
return(Request.CreateResponse(HttpStatusCode.OK, "Available (OK)"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Agent Not Found"));
}
}
catch (Exception ex)
{
Log.logException(ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public HttpResponseMessage HangupPost([FromBody] UserParameters user)
{
try
{
if (MainObject.MainList.ContainsKey(user.AgentId))
{
CApp mpApp = MainObject.MainList[user.AgentId];
mpApp.Hangup(mpApp.CurrentCall, mpApp);
return(Request.CreateResponse(HttpStatusCode.OK, "OK"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Agent Not Found"));
}
}
catch (Exception ex)
{
Log.logException(ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public void FilterAndSearchQuery(UserParameters parameters, ref IQueryable <User> result)
{
if (!parameters.Search.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user =>
user.Email.Contains(parameters.Search) ||
user.Name.Contains(parameters.Search) ||
user.Phone.Contains(parameters.Search) ||
user.Email.Contains(parameters.Search) ||
user.Username.Contains(parameters.Search) ||
user.Website.Contains(parameters.Search));
}
if (!parameters.Email.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user => user.Email == parameters.Email).AsQueryable();
}
if (!parameters.Name.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user => user.Name == parameters.Name).AsQueryable();
}
if (!parameters.Username.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user => user.Username == parameters.Username).AsQueryable();
}
if (!parameters.Phone.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user => user.Phone == parameters.Phone).AsQueryable();
}
if (!parameters.Website.IsNullEmptyOrWhiteSpace())
{
result = result.Where(user => user.Website == parameters.Website).AsQueryable();
}
}
public async Task <IActionResult> GetUsers([FromQuery] UserParameters parameters)
{
try
{
var models = await repository.GetModelList(parameters);
return(Ok(new ConsumptionResponse()
{
success = true,
dynamicObj = models,
TotalRecord = models.TotalCount
}));
}
catch (Exception ex)
{
logger.LogError(ex, "");
return(Ok(new ConsumptionResponse()
{
success = false,
message = "Can't get data"
}));
}
}
public async Task <PagedList <MemberDto> > GetMembersAsync(UserParameters userParameters)
{
var query = this.dataContext.Users.AsQueryable();
query = query.Where(user => user.UserName != userParameters.CurrentUserName);
query = query.Where(user => user.Gender == userParameters.Gender);
var minDateOfBirth = DateTime.Today.AddYears(-userParameters.MaxAge - 1);
var maxDateOfBirth = DateTime.Today.AddYears(-userParameters.MinAge);
query = query.Where(user => user.DateOfBirth >= minDateOfBirth && user.DateOfBirth <= maxDateOfBirth);
query = userParameters.OrderBy switch
{
"created" => query.OrderByDescending(user => user.Created),
_ => query.OrderByDescending(user => user.LastActive),
};
return(await PagedList <MemberDto> .CreateAsync(
query.ProjectTo <MemberDto>(this.mapper.ConfigurationProvider).AsNoTracking(),
userParameters.PageNumber,
userParameters.PageSize));
}
public void ChangePasswordTest_UnapprovedUser_ReturnsFalse()
{
UserParameters u = _testUsers[0];
//Change user to unapproved
var user = _mp.GetUser(u.username, true);
user.IsApproved = false;
_mp.UpdateUser(user);
string newpass = "******";
bool result = true;
result = _mp.ChangePassword(u.username, u.password, newpass);
//Cleanup
if (result)
{
_mp.ChangePassword(u.username, newpass, u.password);
}
user.IsApproved = true;
_mp.UpdateUser(user);
Assert.IsFalse(result);
}
public void ChangePasswordQuestionAndAnswer_ValidUser_QandAChanged()
{
UserParameters uparm = _testUsers[3];
User u = _memberRepo.GetUserByName(uparm.username, _mp.ApplicationName);
var oldQA = new PasswordQandA()
{
Answer = u.PasswordAnswer, Question = u.PasswordQuestion
};
var newQA = new PasswordQandA()
{
Answer = "Lettuce And Carrots", Question = "What Do Rabbits Eat?"
};
_mp.ChangePasswordQuestionAndAnswer(uparm.username, uparm.password, newQA.Question, newQA.Answer);
User uCur = _memberRepo.GetUserByName(uparm.username, _mp.ApplicationName);
oldQA.Question = uCur.PasswordQuestion;
oldQA.Answer = uCur.PasswordAnswer;
//Cleanup
_mp.ChangePasswordQuestionAndAnswer(uparm.username, uparm.password, uparm.passwordQuestion, uparm.passwordAnswer);
Assert.AreEqual(oldQA, newQA);
}
protected AIMQueryParameters(AIMQueryParameters queryParameters)
{
foreach (AimAnatomicEntityQueryData aeQueryData in queryParameters.AeQueryParameters)
{
AeQueryParameters.Add(new AimAnatomicEntityQueryData(aeQueryData));
}
foreach (AimImagingObservationQueryData imQueryData in queryParameters.ImQueryParameters)
{
ImQueryParameters.Add(new AimImagingObservationQueryData(imQueryData));
}
foreach (QueryData queryData in queryParameters.StudyInstanceUidParameters)
{
StudyInstanceUidParameters.Add(new QueryData(queryData));
}
foreach (QueryData queryData in queryParameters.UserParameters)
{
UserParameters.Add(new QueryData(queryData));
}
_annotationType = queryParameters._annotationType;
}
public async Task <PagedList <User> > GetUsersAsync(UserParameters userParameters)
{
var query = FindAll().OrderBy(u => u.RegistrationDate).AsQueryable();
if (userParameters.Email != null)
{
query = query.Where(u => u.Email == userParameters.Email.ToLower());
}
if (userParameters.Starting_After != null)
{
query = query.Where(u => u.Id > userParameters.Starting_After);
}
if (userParameters.Ending_Before != null)
{
query = query.Where(u => u.Id < userParameters.Ending_Before);
}
return(await PagedList <User> .ToPagedListAsync(
query.OrderBy(u => u.RegistrationDate),
userParameters.Page,
userParameters.Limit));
}
public override void initPart(string path)
{
string newPath = Utility.Instance.CopyFile(path);
try
{
// TODO remove polling, use async
m_inventorInstance = Activator.CreateInstance(Type.GetTypeFromProgID("Inventor.Application")) as Inventor.Application;
m_inventorInstance.Visible = false;
bool polling2 = true;
while (polling2)
{
m_partInstance = m_inventorInstance.Documents.Open(@newPath) as PartDocument;
if (m_partInstance == null)
{
System.Threading.Thread.Sleep(10);
//MessageBox.Show("Part from parts library must be opened");
}
else
{
polling2 = false;
}
}
//Console.WriteLine((string)m_partInstance.DisplayName);
// init partparams collection
m_partParams = m_partInstance.ComponentDefinition.Parameters.UserParameters;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
public async Task <IEnumerable <User> > GetAll(UserParameters userParameters)
{
return(await _unitOfWork._userRepository.GetAll(userParameters));
}
public ActionResult UpdateAccount(UserParameters userParameters)
{
_accountLogic.SaveAccount(userParameters.ToUserDataRecord());
return(RedirectToAction("Index", "NewsFeed"));
}
public async Task <ActionResult <IQueryable <ApplicationUserBasicData> > > Get([FromQuery] UserParameters userParameters)
{
var users = await _userManager.Users
.Where(s => s.Enabled == true)
.Select(user => new ApplicationUserBasicData
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
AvatarUrl = user.AvatarUrl,
Roles = string.Join(",", user.Roles.Join(_roleManager.Roles,
userRole => userRole.RoleId,
role => role.Id,
(userRole, role) => role.Name
).ToList())
})
.ToListAsync();
var result = PagedList <ApplicationUserBasicData> .ToPagedList(users, userParameters.PageNumber, userParameters.PageSize);
var metadata = new
{
result.TotalCount,
result.PageSize,
result.CurrentPage,
result.TotalPages,
result.HasNext,
result.HasPrevious
};
Response.Headers.Add("x-pagination", JsonConvert.SerializeObject(metadata));
return(Ok(result));
}
public int CreateUserSettings(UserParameters userSettings)
{
settingsUOW.UserSettingsRepository.Add(userSettings);
return(settingsUOW.Commit());
}
public async Task <ApiResponse> GetAll([FromQuery] UserParameters parameters) => await manager.GetAll(parameters);
public async Task <IEnumerable <User> > GetAll([FromQuery] UserParameters userParameters)
{
return(await _service.GetAll(userParameters));
}
private void pullParents(string parentFileName)
{
// Set parent assembly do to parentFileName
try
{
invApp.Documents.Open(parentFileName, false);
}
catch (Exception e)
{
throw;
}
finally
{
assemblyDoc = (AssemblyDocument)invApp.Documents.ItemByName[parentFileName];
parentAssembly = assemblyDoc.ComponentDefinition;
assemblyParameters = parentAssembly.Parameters.UserParameters;
}
// Get User Parameters from parent file.
ArrayList parentParameters = new ArrayList();
foreach (Parameter p in assemblyParameters)
{
// Store parameter in list if key
if (p.IsKey)
{
parentParameters.Add(p);
}
}
// Add all parameters from list to part file
// Check if parameter already exists
// Add all part parameters to list for comparision
ArrayList partParameters = new ArrayList();
UserParameters childParameters = currentPartDef.Parameters.UserParameters;
foreach (Parameter p in childParameters)
{
partParameters.Add(p.Name);
}
// Add parent parameters to part parameters
foreach (Parameter p in parentParameters)
{
//Check if parameter already exists
if (partParameters.Contains(p.Name))
{
// Try to replace value with parent value
try
{
childParameters[p.Name].Value = p._Value;
}
catch (Exception e)
{
MessageBox.Show("Error:\n" + e.Message);
}
}
else
{
// Try to add the parameter by nominal value
try
{
childParameters.AddByValue(p.Name, p.Value, p.get_Units());
}
catch (Exception e)
{
MessageBox.Show("Error:\n" + e.Message);
}
}
}
}
internal void CompleteInitialization()
{
MinUserArgsAmount = UserParameters.Sum(GetAmountUserArgsNeeded);
MaxUserArgsAmount = GetAmountUserArgsMaxPossible();
ExactUserArgsAmount = GetExactAmounterUserArgsRequired();
}
public static void SaveUserParameters(UserParameters usrParameters)
{
try
{
string sql = "delete from User_Parameters where user_guid='" + usrParameters.User + "'";
using (NpgsqlConnection connection = new NpgsqlConnection(strPostGISConnection))
{
connection.Open();
using (NpgsqlCommand command = new NpgsqlCommand(sql, connection))
{
int rows = command.ExecuteNonQuery();
}
sql = "insert into User_Parameters (user_guid,MapHomeZoom,MapHomeCenterX,MapHomeCenterY) values('" + usrParameters.User + "'," + usrParameters.MapHomeZoom.ToString() + "," + usrParameters.MapHomeCenterX + "," + usrParameters.MapHomeCenterY + ")";
using (NpgsqlCommand command = new NpgsqlCommand(sql, connection))
{
int rows = command.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
}
}
public List <User> getUsers(UserParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
List <User> cases = new List <User>();
bool f = !parameters.variables["limit"]; //Флаг, который отвечает за получение всех или не всех обращений с запроса
int limit = 0, page = 1; //В Omnidesk счет начинается с 0
do
{
RestRequest request = new RestRequest("users.json", Method.GET);
request.AddHeader("Content-Type", "application/json");
if (!f)
{
if (parameters.variables["page"])
{
request.AddParameter("page", parameters.page);
}
if (parameters.variables["limit"])
{
request.AddParameter("limit", parameters.limit);
}
}
else
{
request.AddParameter("page", page);
}
if (parameters.variables["user_email"])
{
request.AddParameter("user_email", parameters.user_email);
}
if (parameters.variables["user_phone"])
{
request.AddParameter("user_phone", parameters.user_phone);
}
if (parameters.variables["language_id"])
{
request.AddParameter("language_id", parameters.language_id);
}
if (parameters.variables["amount_of_cases"])
{
request.AddParameter("amount_of_cases", parameters.amount_of_cases);
}
if (parameters.variables["amount_of_cases"])
{
request.AddParameter("amount_of_cases", parameters.amount_of_cases);
}
var response = Connection.Execute(request);
var content = response.Content;
JObject obj = JObject.Parse(content);
if (f)
{
int.TryParse(obj.GetValue("total_count").ToString(), out limit);
}
foreach (JProperty t in obj.Properties())
{
if (t.Name == "total_count")
{
continue;
}
var c = JsonConvert.DeserializeObject <User>(t.Value["user"].ToString());
cases.Add(c);
}
} while (page++ < limit / 100 + 1);
return(cases);
}
public void RunWithArguments(Document doc, NameValueMap map)
{
LogTrace("Initialiting");
PartDocument oPartDoc = (PartDocument)inventorApplication.Documents.Add(DocumentTypeEnum.kPartDocumentObject, inventorApplication.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject), true);
LogTrace("Part template opened");
TransientGeometry oTG = inventorApplication.TransientGeometry;
PartComponentDefinition oPartComDef = oPartDoc.ComponentDefinition;
UserParameters oParams = oPartComDef.Parameters.UserParameters;
XmlDocument xmlDoc = new XmlDocument();
string currentDir = System.IO.Directory.GetCurrentDirectory();
string projectDir = Directory.GetParent(currentDir).Parent.FullName;
LogTrace("Reading XML input file from " + projectDir);
xmlDoc.Load(System.IO.Path.Combine(projectDir, "react-test-output.xml"));
//xmlDoc.Load("react-test-output.xml");
//xmlDoc.Load("C:\\webapps\\IpartCreator\\React-BIM-output.xml");
XmlNodeList FloorList = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor");
XmlNodeList FloorPointList = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor/BoundaryPoints/Point");
XmlNodeList ComponentName = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor/ComponentName");
XmlNodeList PointX = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor/BoundaryPoints/Point/X");
XmlNodeList PointY = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor/BoundaryPoints/Point/Y");
XmlNodeList PointZ = xmlDoc.DocumentElement.SelectNodes("/Building/Floors/Floor/BoundaryPoints/Point/Z");
for (int i = 0; i < FloorList.Count; i++)
{
//oParams.AddByExpression("ComponentName" + i, ComponentName[i].InnerText, UnitsTypeEnum.kUnitlessUnits);
int numPoint = FloorPointList.Count / FloorList.Count;
Point2d[] oPoints = new Point2d[numPoint];
SketchPoint[] osPoints = new SketchPoint[numPoint];
for (int j = 0; j < numPoint; j++)
{
oParams.AddByExpression("PointX" + j, PointX[j].InnerText, UnitsTypeEnum.kMillimeterLengthUnits);
oParams.AddByExpression("PointY" + j, PointY[j].InnerText, UnitsTypeEnum.kMillimeterLengthUnits);
oParams.AddByExpression("PointZ" + j, PointZ[j].InnerText, UnitsTypeEnum.kMillimeterLengthUnits);
oPoints[j] = oTG.CreatePoint2d(oPartComDef.Parameters.GetValueFromExpression("PointX" + j, UnitsTypeEnum.kMillimeterLengthUnits), oPartComDef.Parameters.GetValueFromExpression("PointY" + j, UnitsTypeEnum.kMillimeterLengthUnits));
}
SketchLine[] oLines = new SketchLine[numPoint];
PlanarSketch oSketch = oPartComDef.Sketches.Add(oPartComDef.WorkPlanes[2]);
osPoints[0] = oSketch.SketchPoints.Add(oPoints[0]);
osPoints[1] = oSketch.SketchPoints.Add(oPoints[1]);
osPoints[2] = oSketch.SketchPoints.Add(oPoints[2]);
osPoints[3] = oSketch.SketchPoints.Add(oPoints[3]);
oLines[0] = oSketch.SketchLines.AddByTwoPoints(osPoints[0], osPoints[1]);
oLines[1] = oSketch.SketchLines.AddByTwoPoints(oLines[0].EndSketchPoint, osPoints[2]);
oLines[2] = oSketch.SketchLines.AddByTwoPoints(oLines[1].EndSketchPoint, osPoints[3]);
oLines[3] = oSketch.SketchLines.AddByTwoPoints(oLines[2].EndSketchPoint, oLines[0].StartSketchPoint);
oSketch.DimensionConstraints.AddTwoPointDistance(osPoints[0], osPoints[1], DimensionOrientationEnum.kAlignedDim, oPoints[1]); //d0//
oSketch.DimensionConstraints.AddTwoPointDistance(osPoints[1], osPoints[2], DimensionOrientationEnum.kAlignedDim, oPoints[3]); //d1//
Profile oProfile = oSketch.Profiles.AddForSolid();
ExtrudeDefinition oExtrudeDef = oPartComDef.Features.ExtrudeFeatures.CreateExtrudeDefinition(oProfile, PartFeatureOperationEnum.kJoinOperation);
oExtrudeDef.SetDistanceExtent(oPartComDef.Parameters.UserParameters.AddByExpression("length", "8", UnitsTypeEnum.kMillimeterLengthUnits), PartFeatureExtentDirectionEnum.kPositiveExtentDirection);
ExtrudeFeature oExtrude = oPartComDef.Features.ExtrudeFeatures.Add(oExtrudeDef);
string PartPath = projectDir + "/results/" + ComponentName[i].InnerText + i + ".ipt";
//string PartPath = ComponentName[i].InnerText + i + ".ipt";
oPartDoc.SaveAs(PartPath, false);
oExtrude.Delete();
}
oPartDoc.Close(false);
AssemblyDocument oAssyDoc = (AssemblyDocument)inventorApplication.Documents.Add(DocumentTypeEnum.kAssemblyDocumentObject, inventorApplication.FileManager.GetTemplateFile(DocumentTypeEnum.kAssemblyDocumentObject), true);
AssemblyComponentDefinition oAssyComDef = oAssyDoc.ComponentDefinition;
ComponentOccurrences oAssyCompOccs = oAssyComDef.Occurrences;
Matrix oPos = oTG.CreateMatrix();
int oStep = 0;
int icomp;
int numite = FloorPointList.Count / FloorList.Count;
for (icomp = 0; icomp <= numite; icomp++)
{
oStep = oStep + 150;
oPos.SetTranslation(oTG.CreateVector(oStep, oStep, 0), false);
string PartPath = projectDir + "/results/" + ComponentName[icomp].InnerText + icomp + ".ipt";
//string PartPath = ComponentName[icomp].InnerText + icomp + ".ipt";
ComponentOccurrence oOcc = oAssyCompOccs.Add(PartPath, oPos);
}
oAssyDoc.SaveAs(projectDir + "/results/result.iam", false);
//oAssyDoc.SaveAs("result.iam", false);
oAssyDoc.Close();
ZipFile.CreateFromDirectory(projectDir + "/results", projectDir + "/forgeResult.zip");
}
public GetAllUsersQuery(UserParameters parameters)
{
usersParameters = parameters;
}
public static UserParameters UserAuthentication(string email, string password)
{
UserParameters userParams = new UserParameters();
try
{
var query = (from usr in DatabaseConnect.DataContext.user_registrations where usr.email == email && usr.password == password select usr).FirstOrDefault();
if (query != null)
{
userParams.UserEmail = query.email;
userParams.UserName = query.name;
userParams.UserID = query.user_id;
}
else
{
userParams = null;
}
}
catch (Exception ex)
{
userParams = null;
}
return userParams;
}
public async Task <ActionResult> Roles(UserParameters parameters)
{
return(View(await UserViewModel.GetModel(DataContext, UserFilter.FromCDSId(parameters.CDSId))));
}
public IQueryable <Transaction> FindTransactionsWithin(UserParameters parameters, IQueryable <Transaction> transactions)
{
return(userSearcher.FindTransactionsWithin(parameters, transactions));
}
public int UpdateUserSettings(UserParameters userSettings)
{
settingsUOW.UserSettingsRepository.AttachForUpdate(userSettings);
settingsUOW.UpdateEntityState(userSettings, EntityState.Modified);
return(settingsUOW.Commit());
}
public static UserParameters GetUserParameters(string userName)
{
try
{
UserParameters parameters = null;
string sql = "select * from User_Parameters where user_guid= '" + userName + "'";
using (NpgsqlConnection connection = new NpgsqlConnection(strPostGISConnection))
using (NpgsqlDataAdapter da = new NpgsqlDataAdapter(sql, connection))
{
DataSet ds = new DataSet();
DataTable dt = new DataTable();
ds.Reset();
da.Fill(ds);
dt = ds.Tables[0];
foreach (DataRow row in dt.Rows)
{
parameters = new UserParameters();
parameters.User = userName;
parameters.MapHomeZoom = System.Convert.ToInt32(row["MapHomeZoom"]);
parameters.MapHomeCenterX = System.Convert.ToDouble(row["MapHomeCenterX"]);
parameters.MapHomeCenterY = System.Convert.ToDouble(row["MapHomeCenterY"]);
}
return parameters;
}
}
catch (Exception ex)
{
}
return null;
}
