Inheritance: RepositoryService, IEntityService
Exemplo n.º 1
0
        public void OnGet(long entityid)
        {
            GetUserProfileViewData();

            eSvc = new EntityService(db, cache);

            Entity entity = eSvc.Get(entityid);

            ViewData["ProductName"]    = entity.EntityName;
            ViewData["ProductOtherId"] = entity.OtherId;

            userid = UserProfile_UserID;

            tSvc = new TemplateService(db, cache);
            string entityChapter = ""; //tSvc.GetEntityChapterData(entityid, "InformationFromExportingSystem");

            if (entityChapter.Trim().Length > 0)
            {
                SysInfo = JsonConvert.DeserializeObject <InformationFromExportingSystem>(entityChapter);
            }
            else
            {
                SysInfo = new InformationFromExportingSystem
                {
                    RegulationsRelatedToCountryOrRegion = new List <RegulationsRelatedToCountryOrRegion>(),
                    SpecialExtensions = new List <Extension>(),
                    RelatedDocuments  = new List <RelatedDocuments>()
                };
            }
        }
        public void DetailedItemViewModelTests_VisibleFields_MultipleEntitiesOfSameTime_ChangesAreReflectedInAllEntities()
        {
            var viewModel = new DetailedItemViewModel(_story);

            viewModel.InitializeAsync().Wait();

            var secondStory = StoryUtilities.CreateStory();

            try
            {
                var secondViewModel = new DetailedItemViewModel(_story);
                secondViewModel.InitializeAsync().Wait();

                ChangeFieldVisibility(viewModel, "Release", false);
                ChangeFieldVisibility(viewModel, "Committers", true);

                var expectedVisibleFields = viewModel.VisibleFields.Select(f => f.Name).OrderBy(f => f).ToList();
                var actualVisibleFields   = secondViewModel.FilteredEntityFields.Where(f => f.IsSelected).Select(f => f.Name).OrderBy(f => f).ToList();
                CollectionAssert.AreEqual(expectedVisibleFields, actualVisibleFields, "Mismathed visible fields");
            }
            finally
            {
                EntityService.DeleteById <Story>(WorkspaceContext, secondStory.Id);
            }
        }
Exemplo n.º 3
0
        private async Task ProcessDeleteCommand(RestProcessParameters param, CancellationToken ct)
        {
            var restQuery        = new RestQueryString(param);
            var entityDefinition = param.Model.EntitiesByPluralName.SafeGet(restQuery.Root);

            if (entityDefinition == null)
            {
                throw new BadRequestException($"Unable to find an entity definition named {restQuery.Root}.");
            }

            if (restQuery.AdditionalQualifier.IsNullOrEmpty())
            {
                throw new BadRequestException($"A delete request must include an id.");
            }

            var result = await EntityService.Delete(entityDefinition, restQuery.AdditionalQualifier, ct);

            if (!result)
            {
                Respond(param,
                        new MessageResponse($"Unable to find a {entityDefinition.SingleName} with id {restQuery.AdditionalQualifier}."),
                        StatusCodes.Status404NotFound);
                return;
            }
            Respond(param, null, StatusCodes.Status204NoContent);
        }
Exemplo n.º 4
0
 public PathController(RoomService roomService, EntityService entityService,
                       NgonbLibraryService ngonbLibraryService)
 {
     _roomService         = roomService;
     _entityService       = entityService;
     _ngonbLibraryService = ngonbLibraryService;
 }
Exemplo n.º 5
0
 public RelationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory,
                        EntityService entityService)
 {
     _uowProvider = uowProvider;
     _repositoryFactory = repositoryFactory;
     _entityService = entityService;
 }
Exemplo n.º 6
0
        private async Task ProcessPostCommand(RestProcessParameters param, CancellationToken ct)
        {
            var restQuery        = new RestQueryString(param);
            var entityDefinition = param.Model.EntitiesByPluralName.SafeGet(restQuery.Root);

            if (entityDefinition == null)
            {
                throw new BadRequestException($"Unable to find an entity definition named {restQuery.Root}.");
            }

            if (!restQuery.AdditionalQualifier.IsNullOrEmpty())
            {
                throw new BadRequestException($"A post request should not have an additional qualifier.");
            }

            var propertyBag = param.RequestSerializer.Deserialize(param.Context.Request.Body);
            var entity      = await EntityFactory.Create(entityDefinition, propertyBag, ct);

            var result = await EntityService.Create(entity, ct);

            Respond(param, result.ToPropertyBag(), StatusCodes.Status201Created, new Dictionary <string, string>
            {
                { WebConstants.ETagHeader, result.Etag },
                { WebConstants.LastModifiedHeader, result.LastModified.SelectOrDefault(x => x.ToUtcIso8601()) },
                {
                    "Location",
                    param.Context.Request.AbsoluteUri(
                        $"{_options.Value.MountPoint}/{entityDefinition.Model.Name}/{entityDefinition.PluralName}/{WebUtility.UrlEncode(result.Id.ToString())}")
                }
            });
        }
Exemplo n.º 7
0
		public void SetDeviceState(SetDeviceStateData setDeviceStateData) {
			var device = UserDeviceService.GetBySecretKey(setDeviceStateData.SecretKey);

			if (device != null) {
				DeviceHistoricalState deviceHistoricalState = new DeviceHistoricalState() {
					State = device.ActualState,
					StateTransitionDateTime = DateTime.Now,
					DeviceId = device.Id
				};

				UserDeviceService.SetupFreshLastPing(device);
				if (UserDeviceService.UpdateDeviceState(device, setDeviceStateData.DeviceState)) {
					var historialStateES = new EntityService<DeviceHistoricalState>();
					historialStateES.Create(deviceHistoricalState);
				}

				IKernel kernel = new StandardKernel(new ConnectYourselfNinjectModule());
				var deviceEventsContainer = kernel.Get<IDevicesEventsContainer>();

				deviceEventsContainer.RegisterDeviceStateChangeEvent(new DeviceStateChangedEvent {
					DeviceId = device.Id,
					DateTime = deviceHistoricalState.StateTransitionDateTime,
					State = setDeviceStateData.DeviceState,
					AppUserId = device.AppUserId
				});
			}
		}
        public async Task <ActionResult> SaveArchivosAdjuntos(ArchivosAdjuntosViewModel viewModel)
        {
            OnBeginCrudAction();

            if (!ModelState.IsValid)
            {
                return(await Task.Run(() => Json(new { success = false, message = GetValidationMessages() }, JsonRequestBehavior.AllowGet)));
            }

            try
            {
                viewModel.Codigo = NumeracionService.GetCodigoSecuencial(EmpresaID, "Archivos Adjuntos", '0', 9);
                var entity = MapperModelToEntity(viewModel);

                var saveResult = await EntityService.SaveAsync(entity);

                if (saveResult.Succeeded)
                {
                    return(await Task.Run(() => Json(new { data = MapperEntityToModel(entity), success = true, message = string.Empty }, JsonRequestBehavior.AllowGet)));
                }

                return(await Task.Run(() => Json(new { success = false, message = saveResult.GetErrorsString() }, JsonRequestBehavior.AllowGet)));
            }
            catch (Exception ex)
            {
                return(Json(new { success = false, message = ex.Message }, JsonRequestBehavior.AllowGet));
            }
        }
Exemplo n.º 9
0
        virtual public async Task Update_EntityUpdated_ShouldSaveToDatabase()
        {
            using AppDbContext dbContext = new AppDbContext(Options, null);
            EntityService <TDto, TInputDto, TEntity> service = GetService(dbContext);

            (TEntity entity, TEntity secondEntity) = GetEntities();


            await dbContext.Set <TEntity>().AddAsync(entity);

            await dbContext.Set <TEntity>().AddAsync(secondEntity);

            await dbContext.SaveChangesAsync();

            using AppDbContext dbContextFetch = new AppDbContext(Options, null);
            TEntity updateEntityFromDb = await dbContextFetch.Set <TEntity>().SingleOrDefaultAsync(e => e.Id == entity.Id);

            updateEntityFromDb = UpdateEntity(updateEntityFromDb, "This was updated");
            TInputDto inputDto = Mapper.Map <TEntity, TDto>(updateEntityFromDb);


            await service.UpdateAsync(secondEntity.Id, inputDto);

            using AppDbContext dbContextAssert = new AppDbContext(Options, null);
            TEntity entityFromDb = await dbContextAssert.Set <TEntity>().SingleOrDefaultAsync(e => e.Id == entity.Id);

            TEntity secondEntityFromDb = await dbContextAssert.Set <TEntity>().SingleOrDefaultAsync(e => e.Id == secondEntity.Id);

            AssertEntitiesAreEqual(entity, entityFromDb);
            AssertEntitiesAreEqual(updateEntityFromDb, secondEntityFromDb);
        }
    /// <summary>
    /// Called when [form bound].
    /// </summary>
    protected override void OnFormBound()
    {
        base.OnFormBound();

        string entityName = EntityService.GetExtendedEntityAttribute("TableName");

        entityName = entityName.Substring(0, 1).ToUpper() + entityName.Substring(1, entityName.Length - 1).ToLower();
        string entityID = EntityService.EntityID.ToString();

        string keyId = "AccountId";

        switch (entityName)
        {
        case "Contact":
            keyId = "ContactId";
            break;

        case "Opportunity":
            keyId = "OpportunityId";
            break;

        case "Ticket":
            keyId = "TicketId";
            break;

        case "Lead":
            keyId = "LeadId";
            break;
        }

        HqlBindingSource.Where     = string.Format("Type = {0} and {1} = '{2}'", (int)HistoryType.atNote, keyId, entityID);
        HqlBindingSource.OrderBy   = "CompletedDate desc";
        HqlBindingSource.BoundGrid = grdNotes;
        grdNotes.DataBind();
    }
Exemplo n.º 11
0
        private void LoadWorkspaces(long sharedSpaceId)
        {
            WorkspaceContext   defaultWorkspaceContext = new WorkspaceContext(sharedSpaceId, 1002);
            LogicalQueryPhrase byName  = new LogicalQueryPhrase(WorkspaceUser.NAME_FIELD, txtName.Text);
            List <QueryPhrase> queries = new List <QueryPhrase>();

            queries.Add(byName);

            EntityListResult <WorkspaceUser> users = EntityService.GetInstance().Get <WorkspaceUser>(defaultWorkspaceContext, queries, null);
            long userId = users.data[0].Id;


            SharedSpaceContext context = new SharedSpaceContext(sharedSpaceId);


            LogicalQueryPhrase byUserId = new LogicalQueryPhrase(WorkspaceUser.ID_FIELD, userId);
            CrossQueryPhrase   byUser   = new CrossQueryPhrase(Workspace.USERS_FIELD, byUserId);

            queries = new List <QueryPhrase>();
            queries.Add(byUser);
            EntityListResult <Workspace> workspaces = EntityService.GetInstance().Get <Workspace>(context, queries, null);

            //User user = GetSharedSpaceUser(sharedSpaceId, txtName.Text);

            FillCombo <Workspace>(cmbWorkspace, workspaces.data);
        }
Exemplo n.º 12
0
        public virtual async Task <IActionResult> Create()
        {
            var context = CreateCreateContext();

            try
            {
                var model = await EntityService.ExecuteCreate(context);

                if (IsJsonRequest())
                {
                    EntityJsonConverter entityConverter = new Mvc.EntityJsonConverter(EntityDomainAuthorizeOption.Create, HttpContext.RequestServices.GetRequiredService <IAuthenticationProvider>().GetAuthentication());
                    return(Content(JsonConvert.SerializeObject(model, entityConverter, EntityMetadataJsonConverter.Converter, PropertyMetadataJsonConverter.Converter, EntityEditModelJsonConverter.Converter), "application/json", System.Text.Encoding.UTF8));
                }
                return(View("Edit", model));
            }
            catch (DomainServiceException ex)
            {
                if (ex.InnerException is UnauthorizedAccessException)
                {
                    return(StatusCode(401, ex.InnerException.Message));
                }
                else
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    throw;
                }
            }
        }
Exemplo n.º 13
0
        private void LoadSharedSpaces()
        {
            EntityListResult <SharedSpace> sharedSpaces = null;

            try
            {
                sharedSpaces = EntityService.GetInstance().Get <SharedSpace>(new SiteContext());
            }
            catch (Exception)
            {
            }
            if (sharedSpaces == null)
            {
                SharedSpace defaultSharedSpace = new SharedSpace();
                defaultSharedSpace.Id   = 1001;
                defaultSharedSpace.Name = "Default shared space";

                sharedSpaces      = new EntityListResult <SharedSpace>();
                sharedSpaces.data = new List <SharedSpace>();
                sharedSpaces.data.Add(defaultSharedSpace);
                sharedSpaces.total_count = 1;
            }
            FillCombo(cmbSharedSpace, sharedSpaces.data);
            //LoadWorkspaces(((SharedSpace)cmbSharedSpace.SelectedItem).Id);
        }
 // GET: MultiFileUpload
 public MultiFileUploadController(OpenAccessContext context, FileService fileService, EntityService entityService, IFileMailer fileMailer)
     : base(context)
 {
     _fileService = fileService;
     _entityService = entityService;
     _fileMailer = fileMailer;
 }
Exemplo n.º 15
0
        public GraphQLQuery(GraphQLService graphQLService, EntityService entityService)
        {
            Name = "Query";
            var schemas = entityService.GetCollectionSchemas();

            foreach (var metaColl in schemas)
            {
                if (Fields.Count(x => x.Name == metaColl.CollectionName) == 0)
                {
                    JObjectRawType type     = new JObjectRawType(this, graphQLService, metaColl, entityService);
                    ListGraphType  listType = new ListGraphType(type);

                    AddField(new FieldType
                    {
                        Name         = metaColl.CollectionName,
                        Type         = listType.GetType(),
                        ResolvedType = listType,
                        Resolver     = new JObjectFieldResolver(graphQLService, entityService),
                        Arguments    = new QueryArguments(
                            type.TableArgs
                            )
                    });
                }
            }
        }
Exemplo n.º 16
0
 public FileShareDialg()
 {
     InitializeComponent();
     Avatars         = new ObservableCollection <GroupWrapper>();
     _messageService = new MessageService();
     _entityService  = new EntityService();
 }
Exemplo n.º 17
0
        public void OctaneMyItemsViewModelTests_Refresh_ItemRemoved_Success()
        {
            var  defect  = DefectUtilities.CreateDefect();
            bool removed = false;

            try
            {
                var viewModel = new OctaneMyItemsViewModel();
                viewModel.LoadMyItemsAsync().Wait();

                var myItems = viewModel.MyItems.ToList();
                Assert.AreEqual(1, myItems.Count(item => item.ID == defect.Id), $"Couldn't find entity {defect.Name}");

                EntityService.DeleteById <Defect>(WorkspaceContext, defect.Id);
                removed = true;

                viewModel.RefreshCommand.Execute(null);

                Utility.WaitUntil(() => viewModel.Mode == MainWindowMode.ItemsLoaded,
                                  "Timeout waiting for Refresh to finish", new TimeSpan(0, 0, 30));

                myItems = viewModel.MyItems.ToList();
                Assert.AreEqual(0, myItems.Count(item => item.ID == defect.Id), $"Found previously deleted entity {defect.Name} after refresh");
            }
            finally
            {
                if (!removed)
                {
                    EntityService.DeleteById <Defect>(WorkspaceContext, defect.Id);
                }
            }
        }
Exemplo n.º 18
0
        public JsonResult InsertInvestment(int caseId, int caseDetailId, DateTime?fechadecision, string payments, string comment, string caseNumber, int beneficiario)
        {
            DateTime workingDate = DateTime.Now;

            var currentCase = CaseService.FindCaseByNumber(caseNumber);

            var transaction = new Transaction
            {
                CaseDetailId      = caseDetailId,
                TransactionTypeId = (int)TransactionTypeEnum.Inversion,
                TransactionDate   = workingDate,
                TransactionAmount = decimal.Zero,
                Comment           = comment
            };

            TransactionService.CreateTransaction(transaction);


            var amount = decimal.Zero;

            var serializedPayments = JsonConvert.DeserializeObject <List <PaymentTransaction> >(payments);

            foreach (var serializedPayment in serializedPayments)
            {
                var entidad = new Entity
                {
                    FullName = serializedPayment.Entidad,
                    SourceId = 9
                };
                EntityService.CreateEntity(entidad);

                var payment = new Payment
                {
                    CaseId           = caseId,
                    CaseDetailId     = caseDetailId,
                    TransactionId    = transaction.TransactionId,
                    CaseNumber       = caseNumber,
                    ConceptId        = currentCase.ConceptId.Value,
                    ClassId          = 3,
                    Amount           = serializedPayment.Inversion,
                    EntityId_RemitTo = entidad.EntityId,
                    Remitter         = entidad,
                    ToDate           = fechadecision,
                    TransactionNum   = transaction.TransactionId.ToString().PadLeft(9, '0'),
                    CheckBk          = 0,
                    StatusId         = 12,
                    IssueDate        = workingDate,
                    StatusChangeDate = workingDate
                };
                amount += serializedPayment.Inversion.Value;

                PaymentService.CreatePayment(payment);
            }

            transaction.TransactionAmount = amount;

            TransactionService.ModifyTransaction(transaction);

            return(Json(new BasicDataTablesResult(new { Status = "OK" })));
        }
        public EntityMemberInfo(EntityService entityService,
                                string memberName, Type memberType,
                                EntityMemberInfo complexParent = null, Type reflectedType = null)
        {
            EntityService   = entityService ?? throw new ArgumentNullException(nameof(entityService));
            Name            = memberName ?? throw new ArgumentNullException(nameof(memberName));
            MemberFinalType = memberType ?? throw new ArgumentNullException(nameof(memberType));

            ComplexParent = complexParent;
            //ComplexName = ComplexParent == null ? Name : $"{ComplexParent.ComplexName}{Defaults.ComplexTypeNameSeparator}{Name}";

            IsDictionaryKey = true; //assume this first

            ReflectedType = reflectedType;

            complexParent?.MemberInfo?.GetMemberType();

            HasComplexParent = ComplexParent != null;

            var root = this;

            do
            {
                ComplexRoot = root;
                root        = ComplexRoot.ComplexParent;
            } while (root != null);
        }
Exemplo n.º 20
0
        public async Task Get_OneEntityWithIncludes()
        {
            using (var context = GetInMemoryContext())
            {
                // Arrange
                var entityService =
                    new EntityService <RemembotSettings>(context, new EntityChangedDispatcher <RemembotSettings>());
                const ulong guildID = 123;

                context.ReminderSettings.Add(new RemembotSettings
                {
                    GuildId            = guildID,
                    RecurringReminders = new List <RecurringReminderMessage>
                    {
                        new RecurringReminderMessage
                        {
                            Message = "TestMessage"
                        }
                    }
                });
                await context.SaveChangesAsync();

                // Act
                var entity = await entityService.Get(r => r.GuildId == guildID, r => r.RecurringReminders);

                // Assert
                Assert.Single(context.RecurringReminderMessages);
                Assert.Equal(guildID, entity.First().GuildId);
                Assert.Equal("TestMessage", entity.First().RecurringReminders.First().Message);
            }
        }
Exemplo n.º 21
0
        public virtual async Task <IActionResult> Remove()
        {
            var context = CreateRemoveContext();

            try
            {
                await EntityService.ExecuteRemove(context);

                return(StatusCode(200));
            }
            catch (DomainServiceException ex)
            {
                if (ex.InnerException is UnauthorizedAccessException)
                {
                    return(StatusCode(401, ex.InnerException.Message));
                }
                else if (ex.InnerException is EntityNotFoundException)
                {
                    return(StatusCode(404, ex.InnerException.Message));
                }
                else
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    throw;
                }
            }
        }
Exemplo n.º 22
0
        public ActionResult Archivos(Guid id)
        {
            var result    = EntityService.GetById(id);
            var resultDto = Mapper.Map <List <ArchivosAdjuntosDetViewModel> >(result.ArchivosAdjuntosDet.ToList());

            return(PartialView(resultDto));
        }
Exemplo n.º 23
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            //injeção de dependência dos bancos / connectionString
            Configuration = Injection.Configuration;
            var connectionString = Configuration["ConnectionStrings:SqlServer"];

            //injetando serviço do dapper
            var dapperContext    = new DapperContext(connectionString);
            var dapperRepository = new DapperRepository(dapperContext);
            var dapperService    = new DapperService(dapperRepository);

            services.AddSingleton <DapperService>(dapperService);

            //injetando serviço do entity
            var entityContext    = new EntityContext(connectionString);
            var entityRepository = new EntityRepository(entityContext);
            var entityService    = new EntityService(entityRepository);

            services.AddSingleton <EntityService>(entityService);


            //injetando serviço do datareader
            var readerContext    = new DataReaderContext(connectionString);
            var readerRepository = new DataReaderRepository(readerContext);
            var readerService    = new DataReaderService(readerRepository);

            services.AddSingleton <DataReaderService>(readerService);
        }
Exemplo n.º 24
0
        public virtual async Task <IActionResult> Update()
        {
            var context = CreateDomainContext();

            try
            {
                var result = await EntityService.ExecuteAsync <IDatabaseContext, IAuthenticationProvider, IValueProvider, EntityDomainAuthorizeOption, IEntityUpdateModel <T> >(context, EntityService.Update);

                if (result.IsSuccess)
                {
                    return(StatusCode(204));
                }
                Response.StatusCode = 400;
                return(Json(result.ErrorMessage.Select(t =>
                                                       new
                {
                    Property = t.Key.ClrName,
                    Name = t.Key.Name,
                    ErrorMessage = t.Value
                })));
            }
            catch (UnauthorizedAccessException ex)
            {
                return(StatusCode(401, ex.Message));
            }
            catch (EntityNotFoundException ex)
            {
                return(StatusCode(404, ex.Message));
            }
        }
Exemplo n.º 25
0
 protected override void Dispose(bool disposing)
 {
     EntityService.Dispose();
     DienteService.Dispose();
     EvolucionesOdontogramaService.Dispose();
     base.Dispose(disposing);
 }
Exemplo n.º 26
0
        public override object GetContent(object model)
        {
            //For testing -- go to the page that use this region and add ?entity=[entityId]
            HttpContext context = HttpContext.Current;

            if (context != null)
            {
                string           entityId = context.Request.QueryString[EntityImagePanel.ENTITY_PARAM];
                CatfishDbContext db       = new CatfishDbContext();
                EntityService    es       = new EntityService(db);

                if (!string.IsNullOrEmpty(entityId)) //get it from url param
                {
                    Entity   = es.GetAnEntity(Convert.ToInt32(entityId));
                    EntityId = Entity.Id;
                }
                else
                {
                    if (EntityId > 0) //the default entity Id
                    {
                        Entity = es.GetAnEntity(Convert.ToInt32(EntityId));
                    }
                }

                if (Entity != null)
                {
                    foreach (var f in ((CFItem)Entity).Files)
                    {
                        CFDataFile img = f;
                        FileGuid = f.Guid;
                    }
                }
            }
            return(base.GetContent(model));
        }
Exemplo n.º 27
0
        public async Task <ActionResult> Print(string curva2, Guid id)
        {
            var consulta = EntityService.GetById(id);
            OdontogramaViewModel consultaDto       = Mapper.Map <OdontogramaViewModel>(consulta);
            ReportingService     _reportingService = new ReportingService("https://simecmexico.jsreportonline.net/", "*****@*****.**", "Simec2015");
            var report = await _reportingService
                         .RenderAsync("ryYnwEtJP", new
            {
                Consulta = consultaDto,
                Imagen   = curva2
            });

            var name = Guid.NewGuid().ToString();

            MemoryStream ms = new MemoryStream();

            report.Content.CopyTo(ms);

            //write to file
            FileStream file = new FileStream(Server.MapPath("~/Content/Reports/" + name + ".pdf"), FileMode.Create, FileAccess.Write);

            ms.WriteTo(file);

            file.Close();
            ms.Close();

            return(Json(new { File = name }, JsonRequestBehavior.AllowGet));
        }
Exemplo n.º 28
0
        private async Task ProcessPutCommand(RestProcessParameters param, CancellationToken ct)
        {
            var restQuery        = new RestQueryString(param);
            var entityDefinition = param.Model.EntitiesByPluralName.SafeGet(restQuery.Root);

            if (entityDefinition == null)
            {
                throw new BadRequestException($"Unable to find an entity definition named {restQuery.Root}.");
            }

            if (restQuery.AdditionalQualifier.IsNullOrEmpty())
            {
                throw new BadRequestException($"A put request must apply to a specific id.");
            }

            var propertyBag = param.RequestSerializer.Deserialize(param.Context.Request.Body);

            propertyBag[MetaConstants.IdProperty] = restQuery.AdditionalQualifier;
            var entity = await EntityFactory.Hydrate(entityDefinition, propertyBag, ct);

            entity.Etag = param.Headers.IfNoneMatch();
            var result = await EntityService.Update(entity, ct);

            Respond(param, result.ToPropertyBag(), StatusCodes.Status200OK, new Dictionary <string, string>
            {
                { WebConstants.ETagHeader, entity.Etag },
                { WebConstants.LastModifiedHeader, result.LastModified.SelectOrDefault(x => x.ToUtcIso8601()) }
            });
        }
Exemplo n.º 29
0
        public override object GetContent(object model)
        {
            //For testing -- go to the page that use this region and add ?entity=[entityId]
            HttpContext context = HttpContext.Current;

            if (context != null)
            {
                string entityId = context.Request.QueryString[EntityContainer.ENTITY_PARAM];

                if (!string.IsNullOrEmpty(entityId))
                {
                    CatfishDbContext db = new CatfishDbContext();
                    EntityService    es = new EntityService(db);

                    Entity         = es.GetAnEntity(Convert.ToInt32(entityId));
                    RelatedMembers = (Entity as CFItem).RelatedMembers.ToList();
                }
            }
            if (PageId != null)
            {
                PageService pageService = new PageService();
                var         page        = pageService.GetAPage(PageId);
                PageLink = page.Permalink;
            }
            return(base.GetContent(model));
        }
Exemplo n.º 30
0
        public IEnumerable <EntityViewModel> GetParents()
        {
            CatfishDbContext context = new CatfishDbContext();
            EntityService    es      = new EntityService(context);

            return(es.GetEntityParents(Id).ToList().Select(e => new EntityViewModel(e, LanguageCodes)));
        }
Exemplo n.º 31
0
        public HttpStatusCodeResult Unstar(int id)
        {
            var conversation = ConversationService.Get(id);

            EntityService.Unstar(conversation);
            return(new HttpStatusCodeResult(HttpStatusCode.OK));
        }
Exemplo n.º 32
0
        public async Task <JsonResult> GetValues()
        {
            try
            {
                var elements = await EntityService.GetAllAsync();

                var result = await elements.Select(q => new
                {
                    value = q.Id,
                    text  = q.Descripcion
                }).ToListAsync();

                return(Json(new
                {
                    success = true,
                    values = (object)result
                }, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(new
                {
                    success = false,
                    values = default(object)
                }, JsonRequestBehavior.AllowGet));
            }
        }
        public IHttpActionResult GetDeviceStatesHistory(string deviceId, int startIndex = 0, int limit = 30)
        {
            var userId = User.Identity.GetUserId();
            UserDeviceService userDeviceService = new UserDeviceService();

            Device device = userDeviceService.GetById(deviceId);

            if (device != null)
            {
                if (device.AppUserId == userId)
                {
                    var deviceStatesHistoryES = new EntityService <DeviceHistoricalState>();
                    var deviceStatesHistory   = deviceStatesHistoryES.Collection.AsQueryable().
                                                Where(x => x.DeviceId == deviceId).
                                                OrderByDescending(x => x.StateTransitionDateTime).
                                                Skip(startIndex).
                                                Take(limit).
                                                ToList();

                    return(Ok(deviceStatesHistory));
                }
                return(BadRequest("Device does not available"));
            }

            return(BadRequest("Device does not exist"));
        }
Exemplo n.º 34
0
        public void TestGetAllParentEntities()
        {
            using (UnitOfWork unitwork = new UnitOfWork(store, dbContextFactory))
            {
                IRepository<Entity, Guid> repository = new Repository<Entity, Guid>(store);

                EntityService service = new EntityService();
                ICollection<Entity> entities = service.GetAllParentEntities(repository.Query(q => q.Name == "Section").First().Id);
                Assert.AreEqual(1, entities.Count);
            }
        }
		public IHttpActionResult GetDeviceStatesHistory(string deviceId, int startIndex = 0, int limit = 30) {
			var userId = User.Identity.GetUserId();
			UserDeviceService userDeviceService = new UserDeviceService();

			Device device = userDeviceService.GetById(deviceId);

			if (device != null) {
				if (device.AppUserId == userId) {
					var deviceStatesHistoryES = new EntityService<DeviceHistoricalState>();
					var deviceStatesHistory = deviceStatesHistoryES.Collection.AsQueryable().
						Where(x => x.DeviceId == deviceId).
						OrderByDescending(x => x.StateTransitionDateTime).
						Skip(startIndex).
						Take(limit).
						ToList();

					return Ok(deviceStatesHistory);
				}
				return BadRequest("Device does not available");
			}

			return BadRequest("Device does not exist");
		}
Exemplo n.º 36
0
        public Account AddAccount(Account account, bool isRoot=false)
        {
            using (UnitOfWork.Start())
            {
                using (accountService = new EntityService<Account>(new Repository<Account>()))
                {
                    if (isRoot)
                    {
                        account.Parent = null;
                    }
                    var olds = accountService.FindByProperty("AccountName", account.AccountName.Trim());
                    if (olds != null && olds.Count > 0)
                    {
                        throw new Exception("Account {0}- {1} already exists.");
                    }
                    else {
                        return accountService.Save(account);
                    }

                }
            }

        }
Exemplo n.º 37
0
        static void Main(string[] args)
        {


            using (UnitOfWork.Start())
            {
                //  BuildSchema(UnitOfWork.Configuration);



                var _AccountRepository = new Repository<Account>();
                EntityService<Account> service = new EntityService<Account>(_AccountRepository);
                service.Saved += Service_Saved;

                var tableAcc = new Account
                {
                    AccountCode = 2,
                    IsActive = true,
                    AccountName = "Sales",
                    TrialBalance = 0,
                    Description = "Sales account",
                    //  Parent = parent
                };


             //   service.Save(tableAcc);
               
                var accounts = service.FindAll("Id");
                foreach (var account in accounts)
                {
                    if (account.Parent == null)
                        System.Console.WriteLine(account.ToString());
                }
                System.Console.ReadKey();
            }
        }
Exemplo n.º 38
0
        static void Main(string[] args)
        {
            using (var studContext = new StudBankContext(true))
            {
                var AccountService = new AccountService(studContext);
                Console.WriteLine("Accounts:");
                foreach(var account in AccountService.Get())
                {
                    System.Console.WriteLine(string.Format("{0} {1} {2} {3} Transfers From: {4}  Transfers To:{5}",
                        account.IBAN, account.AccountType, account.MoneyAmount, account.Currency, account.BankTransfersFrom.Count, account.BankTransfersTo.Count));
                }

                var BankTransferService = new BankTransferService(studContext);
                Console.WriteLine("Transfers:");
                foreach (var transfer in BankTransferService.Get(includeProperties: "AccountFrom,AccountTo"))
                    Console.WriteLine(string.Format("From: {0} To: {1} {2} {3} {4}", transfer.AccountFrom.IBAN, transfer.AccountTo.IBAN,
                        transfer.Amount, transfer.Currency, transfer.TransferDate.ToShortDateString()));

                var LoanAgreementService = new LoanAgreementService(studContext);
                Console.WriteLine("Loan Agreements:");
                foreach (var loanAgreement in LoanAgreementService.Get(includeProperties: "PayoutStatus"))
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} {5} {6}", loanAgreement.Client.FirstName, loanAgreement.LoanType,
                        loanAgreement.LoanProviding, loanAgreement.LoanRepayment, loanAgreement.Term, loanAgreement.Amount, loanAgreement.Currency));

                var PayoutService = new PayoutService(studContext);
                Console.WriteLine("Payouts:");
                foreach (var payout in PayoutService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} {5}", payout.PayoutWay, payout.LoanAmount, payout.ProcessingFee,
                        payout.InterestAmount, payout.TotalAmount, payout.Currency));

                var FineService = new FineService(studContext);
                Console.WriteLine("Fines:");
                foreach (var fine in FineService.Get(includeProperties: "LoanAgreement"))
                    Console.WriteLine(string.Format("{0} {1} {2} {3}", fine.LoanAgreement.Id,
                        fine.DeadLineDate.ToShortDateString(), fine.FineRateOfInterest, fine.IsClosed));

                var WithdrawalService = new WithdrawalService(studContext);
                Console.WriteLine("Withdrawals:");
                foreach (var withdrawal in WithdrawalService.Get(includeProperties: "ClientAccount,LoanAgreement"))
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4}", withdrawal.ClientAccount.Id, withdrawal.MoneyAmount,
                        withdrawal.Currency, withdrawal.WithdrawalWay, withdrawal.Date.ToShortDateString()));

                var PersonService = new PersonService(studContext);
                Console.WriteLine("Persons:");
                foreach (var person in PersonService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} Documents: {3} Records: {4}", person.FirstName, person.IdentificationNumber,
                        person.MonthlyIncome, person.Documents.Count, person.CreditHistoryRecords.Count));

                var HistoryService = new CreditHistoryRecordService(studContext);
                Console.WriteLine("Records:");
                foreach (var record in HistoryService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4}", record.Person.FirstName, record.BankConstants.BIC,
                        record.Amount, record.Currency, record.Interest));

                var LoanService = new LoanService(studContext);
                Console.WriteLine("Loan programs:");
                foreach (var program in LoanService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} {5}", program.Name, program.LoanProviding,
                        program.LoanGuarantee, program.LoanRepayment, program.LoanType, program.MaxAmount));

                var LoanApplicationService = new LoanApplicationService(studContext);
                Console.WriteLine("Loan applications:");
                foreach (var loanApplication in LoanApplicationService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} First surety:{5}", loanApplication.Client.FirstName, loanApplication.Loan.Name,
                        loanApplication.Amount, loanApplication.Currency, loanApplication.Term, loanApplication.Sureties.FirstOrDefault().FirstName));

                var SuretyAgreementService = new SuretyAgreementService(studContext);
                Console.WriteLine("Surety agreements:");
                foreach (var suretyAgreement in SuretyAgreementService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} {5}", suretyAgreement.Client.FirstName, suretyAgreement.Guarantor.FirstName,
                        suretyAgreement.Amount, suretyAgreement.Currency, suretyAgreement.LoanTerm, suretyAgreement.SuretyTerm));

                var BailAgreementService = new BailAgreementService(studContext);
                Console.WriteLine("Bail agreements:");
                foreach (var bailAgreement in BailAgreementService.Get())
                    Console.WriteLine(string.Format("{0} {1} {2} {3} {4} {5}", bailAgreement.Client.FirstName, bailAgreement.BailObject,
                        bailAgreement.Amount, bailAgreement.Currency, bailAgreement.LoanTerm, bailAgreement.BailTerm));

                var SystemService = new SystemResolutionService(studContext);
                Console.WriteLine("System resolutions:");
                foreach (var resolution in SystemService.Get())
                    Console.WriteLine(string.Format("Application: {0} {1} {2}", resolution.LoanApplication.Id, resolution.MaxLoanAmount,
                        resolution.ScoringPoint));

                var SecurityService = new SecurityResolutionService(studContext);
                Console.WriteLine("Security resolutions:");
                foreach (var resolution in SecurityService.Get())
                    Console.WriteLine(string.Format("Application: {0} {1} {2}", resolution.LoanApplication.Id, resolution.Property,
                        resolution.PropertyEstimate));

                var ExpertService = new ExpertResolutionService(studContext);
                Console.WriteLine("Expert resolutions:");
                foreach (var resolution in ExpertService.Get())
                    Console.WriteLine(string.Format("Application: {0} {1} {2}", resolution.LoanApplication.Id, resolution.Property,
                        resolution.PropertyEstimate));

                var CommitteeService = new CommitteeResolutionService(studContext);
                Console.WriteLine("Committee resolutions:");
                foreach (var resolution in CommitteeService.Get())
                    Console.WriteLine(string.Format("Link: {0} {1}", resolution.ProtocolDocument.Link, resolution.Resolution));
            }

            Console.WriteLine("\nAuthentification: ");
            using (var authContext = new StudAuthorizeContext(true))
            {
                var userService = new EntityService<User>(authContext);
                var roleService = new EntityService<Role>(authContext);
                foreach (var user in userService.Get(includeProperties: "Roles"))
                {
                    System.Console.WriteLine(string.Format("{0} {1} {2} {3}", user.FirstName,
                        user.MiddleName, user.LastName, user.Roles.First().Name));
                }
                System.Console.WriteLine();

                userService.Get(user => user.FirstName == "Ivan").First().FirstName = "Vano";
                authContext.SaveChanges();

                foreach (var user in userService.Get(includeProperties: "Roles"))
                {
                    System.Console.WriteLine(string.Format("{0} {1} {2} {3}", user.FirstName,
                        user.MiddleName, user.LastName, user.Roles.First().Name));
                }
            }

            System.Console.ReadKey(true);
        }
Exemplo n.º 39
0
 public FilesController(EntityService entityService, FileService fileService)
 {
     _entityService = entityService;
     _fileService = fileService;
 }
		public IHttpActionResult SetDeviceState(SetDeviceStateData setDeviceStateData) {
			var userId = User.Identity.GetUserId();
			UserDeviceService userDeviceService = new UserDeviceService();

			if (setDeviceStateData == null) {
				return BadRequest("Input is null");
			}

			var device = userDeviceService.GetBySecretKey(setDeviceStateData.SecretKey);

			if (device != null) {
				DeviceHistoricalState deviceHistoricalState = new DeviceHistoricalState() {
					State = device.ActualState,
					StateTransitionDateTime = DateTime.Now,
					DeviceId = device.Id
				};

				if (userDeviceService.UpdateDeviceState(device, setDeviceStateData.DeviceState)) {
					var historialStateES = new EntityService<DeviceHistoricalState>();
					historialStateES.Create(deviceHistoricalState);

					IKernel kernel = new StandardKernel(new ConnectYourselfNinjectModule());
					var deviceEventsContainer = kernel.Get<IDevicesEventsContainer>();

					deviceEventsContainer.RegisterDeviceStateChangeEvent(new DeviceStateChangedEvent {
						DeviceId = device.Id,
						DateTime = deviceHistoricalState.StateTransitionDateTime,
						State = setDeviceStateData.DeviceState,
						AppUserId = device.AppUserId
					});

					//send state change message to device
					if (device.ConnectionState == DeviveConnectionState.FullDuplex && !String.IsNullOrEmpty(device.ConnectionId)) {
						var devicesHub = GlobalHost.ConnectionManager.GetHubContext<DevicesHub>();
						devicesHub.Clients.Client(device.ConnectionId).RemoteSetState(setDeviceStateData.DeviceState);
					}

					return Ok();
				} else {
					return BadRequest("Failed to update state device");
				}
			} else {
				return BadRequest("Device does not exists");
			}
		}