예제 #1
0
        public void DataProvider_ListMetadataFormats()
        {
            string expected = $@"{_xmlRoot}
{_oaiPmhRoot}
  <responseDate>2018-05-08T11:05:00Z</responseDate>
  <request verb=""ListMetadataFormats"">{_baseUrl}</request>
  <ListMetadataFormats>
    <metadataFormat>
      <metadataPrefix>oai_dc</metadataPrefix>
      <schema>http://www.openarchives.org/OAI/2.0/oai_dc.xsd</schema>
      <metadataNamespace>http://www.openarchives.org/OAI/2.0/oai_dc/</metadataNamespace>
    </metadataFormat>
    <metadataFormat>
      <metadataPrefix>rdf</metadataPrefix>
      <schema>http://www.openarchives.org/OAI/2.0/rdf.xsd</schema>
      <metadataNamespace>http://www.w3.org/1999/02/22-rdf-syntax-ns#</metadataNamespace>
    </metadataFormat>
  </ListMetadataFormats>
</OAI-PMH>";

            var arguments = new ArgumentContainer(OaiVerb.ListMetadataFormats.ToString());
            var actual    = _dataProvider.ToString(new DateTime(2018, 5, 8, 11, 5, 0, DateTimeKind.Utc), arguments);

            Assert.AreEqual(expected, actual);
        }
예제 #2
0
        protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
        {
            ArgumentContainer argOut = new ArgumentContainer();

            if (!ArgumentParsing.TryParseGuildTextChannel(context, context.Arguments.First, out argOut.channel))
            {
                return(Task.FromResult(new ArgumentParseResult(Arguments[0], "Failed to parse to a guild text channel!")));
            }

            if (context.Message.Content.Length > Identifier.Length + context.Arguments.First.Length + 2)
            {
                context.Arguments.Index++;
                string embedText = context.RemoveArgumentsFront(1).Replace("[3`]", "```");

                if (JSONContainer.TryParse(embedText, out JSONContainer json, out string errormessage))
                {
                    if (EmbedHelper.TryGetMessageFromJSONObject(json, out argOut.embed, out argOut.messageContent, out string error))
                    {
                        return(Task.FromResult(new ArgumentParseResult(argOut)));
                    }
                    else
                    {
                        return(Task.FromResult(new ArgumentParseResult(Arguments[1], error)));
                    }
                }
                else
                {
                    return(Task.FromResult(new ArgumentParseResult(Arguments[1], $"Unable to parse JSON text to a json data structure! Error: `{errormessage}`")));
                }
            }
예제 #3
0
파일: Actuator.cs 프로젝트: hwacha/entale
    protected IEnumerator Say(Expression e, float time)
    {
        // TODO: figure this stuff out
        // var eWithoutParameters = new Container<Expression>(null);
        // Agent.MentalState.StartCoroutine(Agent.MentalState.ReplaceParameters(e, eWithoutParameters));

        // while (eWithoutParameters.Item == null) {
        //     yield return null;
        // }

        // GameObject eContainer = ArgumentContainer.From(eWithoutParameters.Item);

        var eContainer = ArgumentContainer.From(e);
        ArgumentContainer eContainerScript = eContainer.GetComponent <ArgumentContainer>();

        eContainerScript.GenerateVisual();

        var display = Agent.gameObject.transform.Find("Display");

        eContainer.transform.position    = display.position;
        eContainer.transform.rotation    = display.rotation;
        eContainer.transform.localScale *= 0.5f;
        eContainer.transform.SetParent(display);

        yield return(new WaitForSeconds(time));

        Destroy(eContainer);
        yield break;
    }
예제 #4
0
        public void DataProvider_GetRecord()
        {
            string expected = $@"{_xmlRoot}
{_oaiPmhRoot}
  <responseDate>2018-05-08T11:05:00Z</responseDate>
  <request verb=""GetRecord"" identifier=""12"" metadataPrefix=""oai_dc"">http://localhost/test</request>
  <GetRecord>
    <record>
      <header>
        <identifier>12</identifier>
        <datestamp>2018-02-16T02:00:00Z</datestamp>
      </header>
      <metadata>
        {_oaiDcRoot}
          <dc:title>Title 2</dc:title>
          <dc:creator>Owner 2</dc:creator>
          <dc:date>2018-02-16T02:00:00Z</dc:date>
          <dc:identifier>12</dc:identifier>
        </oai_dc:dc>
      </metadata>
    </record>
  </GetRecord>
</OAI-PMH>";

            var arguments = new ArgumentContainer(OaiVerb.GetRecord.ToString(), "oai_dc", string.Empty, "12");
            var actual    = _dataProvider.ToString(new DateTime(2018, 5, 8, 11, 5, 0, DateTimeKind.Utc), arguments);

            Assert.AreEqual(expected, actual);
        }
예제 #5
0
        public override IElement Action(ArgumentContainer Args)
        {
            // let's assume that all parameters are collections of the form:
            // [condition-expr then-expr]

            foreach (var param in Args.GetRawRestArguments().Value)
            {
                if (param is Collection cond)
                {
                    var values = cond.GetInnerValues();
                    if (values.Count == 2)
                    {
                        var testResult = Interpreter.VisitAndGetResult(values.First());

                        if (testResult is TrueFalse tf)
                        {
                            if (tf.Value == true)
                            {
                                return(Interpreter.VisitAndGetResult(values.Skip(1).First()));
                            }
                            // else move on to the next pair
                        }
                        else
                        {
                            throw new TypeException("Returned value to IF was not a boolean value!");
                        }
                    }
                    else
                    {
                        throw new TypeException("IF must recieve collections with exactly 2 items in each");
                    }
                }
            }
            return(new Noop());
        }
예제 #6
0
        public void Video_Duration()
        {
            var video  = VideoInfo.FromFileInfo(VideoLibrary.LocalVideo);
            var output = Input.OutputLocation(VideoType.Mp4);

            var arguments = new ArgumentContainer();

            arguments.Add(new InputArgument(VideoLibrary.LocalVideo));
            arguments.Add(new DurationArgument(TimeSpan.FromSeconds(video.Duration.TotalSeconds - 5)));
            arguments.Add(new OutputArgument(output));

            try {
                Encoder.Convert(arguments);

                Assert.IsTrue(File.Exists(output.FullName));
                var outputVideo = new VideoInfo(output.FullName);

                Assert.AreEqual(video.Duration.Days, outputVideo.Duration.Days);
                Assert.AreEqual(video.Duration.Hours, outputVideo.Duration.Hours);
                Assert.AreEqual(video.Duration.Minutes, outputVideo.Duration.Minutes);
                Assert.AreEqual(video.Duration.Seconds - 5, outputVideo.Duration.Seconds);
            } finally {
                if (File.Exists(output.FullName))
                {
                    output.Delete();
                }
            }
        }
예제 #7
0
        public IElement OnAction(List <IElement> Arguments)
        {
            var args = new ArgumentContainer();

            args.InputSignature(cachedSignature, Arguments);
            return(Action(args));
        }
예제 #8
0
        /// <summary>
        /// Transforms the provided OAI-PMH arguments to an XML document.
        /// </summary>
        /// <param name="date">The date to be included in the response.</param>
        /// <param name="arguments">The OAI-PMH arguments.</param>
        /// <returns>The transformed OAI-PMH arguments as an XML document.</returns>
        public XDocument ToXDocument(DateTime date, ArgumentContainer arguments)
        {
            if (Enum.TryParse(arguments.Verb, out OaiVerb parsedVerb))
            {
                switch (parsedVerb)
                {
                case OaiVerb.Identify:
                    return(CreateIdentify(date, arguments));

                case OaiVerb.ListMetadataFormats:
                    return(CreateListMetadataFormats(date, arguments));

                case OaiVerb.ListRecords:
                    return(CreateListIdentifiersOrRecords(date, arguments, parsedVerb));

                case OaiVerb.ListIdentifiers:
                    return(CreateListIdentifiersOrRecords(date, arguments, parsedVerb));

                case OaiVerb.GetRecord:
                    return(CreateGetRecord(date, arguments));

                case OaiVerb.ListSets:
                    return(CreateListSets(date, arguments));

                case OaiVerb.None:
                default:
                    return(CreateErrorDocument(date, OaiVerb.None, arguments, OaiErrors.BadVerb));
                }
            }
            else
            {
                return(CreateErrorDocument(date, OaiVerb.None, arguments, OaiErrors.BadVerb));
            }
        }
예제 #9
0
        public void Video_ToMP4_Args()
        {
            var container = new ArgumentContainer();

            container.Add(new VideoCodecArgument(VideoCodec.LibX264));
            Convert(VideoType.Mp4, container);
        }
        /// <summary>
        /// Obtiene los records del repositorio en función de los argumentos pasados
        /// </summary>
        /// <param name="arguments">Parámetros de la consulta</param>
        /// <param name="resumptionToken">Token de reanudación</param>
        /// <returns></returns>
        public RecordContainer GetRecords(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
        {
            RecordContainer container = new RecordContainer();
            DateTime        inicio    = DateTime.MinValue;

            if (_dateConverter.TryDecode(arguments.From, out DateTime from))
            {
                inicio = from;
            }

            HashSet <string> ids     = GetCurriculumsIDs(inicio, _configOAI_PMH_CVN.GetXML_CVN_Repository());
            List <CVN>       listCVN = new List <CVN>();

            foreach (string id in ids)
            {
                DateTime date = DateTime.UtcNow.AddDays(-100 + int.Parse(id));
                if (date > inicio)
                {
                    listCVN.Add(GetCurriculum(id, arguments.Verb == OaiVerb.ListIdentifiers.ToString(), _configOAI_PMH_CVN.GetXML_CVN_Repository()));
                }
            }
            if (arguments.Verb == OaiVerb.ListIdentifiers.ToString())
            {
                container.Records = listCVN.Select(r => ToIdentifiersRecord(r));
            }
            else
            {
                container.Records = listCVN.Select(r => ToRecord(r, arguments.MetadataPrefix));
            }
            container.Records = container.Records.Where(x => x.Header.Datestamp > inicio).ToList();
            return(container);
        }
예제 #11
0
        /// <summary>
        /// split video by time lines in Dir
        /// </summary>
        /// <param name="timeLines">time lines</param>
        public void Split(TimeLineVolume[] timeLines)
        {
            char   sep    = Path.DirectorySeparatorChar;
            FFMpeg ffmpeg = new FFMpeg();

            for (int i = 0; i < timeLines.Length; i++)
            {
                ArgumentContainer container = new ArgumentContainer();
                // input arg
                container.Add(new InputArgument(Source));

                // split arg
                container.Add(new SplitArgument(timeLines[i]));

                // output path
                VideoPartInfo partInfo = new VideoPartInfo()
                {
                    IsNoise       = timeLines[i].Volume == VolumeValue.Noise ? true: false,
                    Name          = "videoPart",
                    FileExtension = SourceExtension,
                    Number        = i,
                };
                string outputPath = $"{Dir.FullName}{sep}{partInfo.FullName}";
                container.Add(new OutputArgument(outputPath));

                // convert
                ffmpeg.Convert(container);
            }
        }
        public FileResult Get(OaiVerb verb, string identifier = "", string metadataPrefix = "", string from = "", string until = "", string set = "", string resumptionToken = "")
        {
            //CONFIG OAI-PMH
            _configOAI.BaseUrl = () =>
            {
                Uri baseUri = new Uri(_configOAI_PMH_CVN.GetConfigUrl());
                return(baseUri.AbsoluteUri);
            };


            //MetadataFormatRepository
            MetadataFormatRepository metadataFormatRepository = new MetadataFormatRepository();

            RecordRepository recordRepository = new RecordRepository(_configOAI, _configOAI_PMH_CVN);

            //SetRepository
            SetRepository setRepository = new SetRepository(_configOAI);

            DataProvider provider = new DataProvider(_configOAI, metadataFormatRepository, recordRepository, setRepository);

            ArgumentContainer arguments = new ArgumentContainer(verb.ToString(), metadataPrefix, resumptionToken, identifier, from, until, set);
            XDocument         document  = provider.ToXDocument(DateTime.Now.AddMinutes(100), arguments);

            var memoryStream = new MemoryStream();
            var xmlWriter    = XmlWriter.Create(memoryStream);

            document.WriteTo(xmlWriter);
            xmlWriter.Flush();
            byte[] array = memoryStream.ToArray();
            return(File(array, "application/xml"));
        }
예제 #13
0
        public void Video_UpdatesProgress()
        {
            var output = Input.OutputLocation(VideoType.Mp4);

            var percentageDone = 0.0;

            void OnProgess(double percentage) => percentageDone = percentage;

            Encoder.OnProgress += OnProgess;

            var arguments = new ArgumentContainer
            {
                new InputArgument(VideoLibrary.LocalVideo),
                new DurationArgument(TimeSpan.FromSeconds(8)),
                new OutputArgument(output)
            };

            try {
                Encoder.Convert(arguments);
                Encoder.OnProgress -= OnProgess;

                Assert.IsTrue(File.Exists(output.FullName));
                Assert.AreNotEqual(0.0, percentageDone);
            } finally {
                if (File.Exists(output.FullName))
                {
                    output.Delete();
                }
            }
        }
예제 #14
0
        public void Video_ToOGV_Resize_Args()
        {
            var container = new ArgumentContainer();

            container.Add(new ScaleArgument(VideoSize.Ed));
            container.Add(new VideoCodecArgument(VideoCodec.LibTheora));
            Convert(VideoType.Ogv, container);
        }
예제 #15
0
 /// <summary>
 /// Obtiene los sets del repositorio en función de los argumentos pasados
 /// </summary>
 /// <param name="arguments">Parámetros de la consulta</param>        
 /// <param name="resumptionToken">Token de reanudación</param>
 /// <returns></returns>
 public SetContainer GetSets(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
 {
     SetContainer container = new SetContainer();
     IQueryable<Set> sets = _sets.AsQueryable().OrderBy(s => s.Name);
     int totalCount = sets.Count();
     container.Sets = sets.Take(_configuration.PageSize);
     return container;
 }
예제 #16
0
        public override IElement Action(ArgumentContainer Args)
        {
            var joining = Args.GetVisitedArgumentAs <Str>("separator");
            var list    = Args.GetVisitedArgumentAs <Collection>("alist");
            var items   = list.Value.Select(item => item.Repr());

            return(new Str().Initialize(String.Join(joining.Value, items)));
        }
예제 #17
0
        private static List <T> ArgumentContainerToList <T>(ArgumentContainer <string, object> argumentList, string itemName)
        {
            if (!argumentList.ContainsKey(itemName))
            {
                return(new List <T>());
            }

            return(ArrayOrItemToList <T>(argumentList[itemName]));
        }
예제 #18
0
        private XDocument CreateErrorDocument(DateTime date, OaiVerb verb, ArgumentContainer arguments, XElement error)
        {
            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));
            root.Add(error);

            return(CreateXml(date, root.ToArray()));
        }
예제 #19
0
        public void Video_ToTS_Args()
        {
            var container = new ArgumentContainer();

            container.Add(new CopyArgument());
            container.Add(new BitStreamFilterArgument(Channel.Video, Filter.H264_Mp4ToAnnexB));
            container.Add(new ForceFormatArgument(VideoCodec.MpegTs));
            Convert(VideoType.Ts, container);
        }
예제 #20
0
        public void Video_ToMP4_Resize_Args()
        {
            var container = new ArgumentContainer
            {
                new ScaleArgument(VideoSize.Ld),
                new VideoCodecArgument(VideoCodec.LibX264)
            };

            Convert(VideoType.Mp4, container);
        }
예제 #21
0
    GameObject SpawnArgumentContainer(Expression e, Vector3 pos, Quaternion rot)
    {
        var argContainer = ArgumentContainer.From(e);

        argContainer.GetComponent <ArgumentContainer>().GenerateVisual();
        argContainer.transform.position = pos;
        argContainer.transform.rotation = rot;

        return(argContainer);
    }
예제 #22
0
        public void Convert(VideoType type, ArgumentContainer container)
        {
            var output = Input.OutputLocation(type);

            try
            {
                var input = VideoInfo.FromFileInfo(Input);

                var arguments = new ArgumentContainer {
                    new InputArgument(input)
                };
                foreach (var arg in container)
                {
                    arguments.Add(arg.Value);
                }
                arguments.Add(new OutputArgument(output));

                var scaling = container.Find <ScaleArgument>();

                Encoder.Convert(arguments);

                var outputVideo = new VideoInfo(output.FullName);

                Assert.IsTrue(File.Exists(output.FullName));
                Assert.AreEqual(outputVideo.Duration, input.Duration);

                if (scaling == null)
                {
                    Assert.AreEqual(outputVideo.Width, input.Width);
                    Assert.AreEqual(outputVideo.Height, input.Height);
                }
                else
                {
                    if (scaling.Value.Width != -1)
                    {
                        Assert.AreEqual(outputVideo.Width, scaling.Value.Width);
                    }

                    if (scaling.Value.Height != -1)
                    {
                        Assert.AreEqual(outputVideo.Height, scaling.Value.Height);
                    }

                    Assert.AreNotEqual(outputVideo.Width, input.Width);
                    Assert.AreNotEqual(outputVideo.Height, input.Height);
                }
            }
            finally
            {
                if (File.Exists(output.FullName))
                {
                    File.Delete(output.FullName);
                }
            }
        }
예제 #23
0
        protected override async Task ExecuteGuild(IGuildCommandContext context, object argObj)
        {
            ArgumentContainer args = argObj as ArgumentContainer;

            GuildModerationLog  guildModerationLog = GuildModerationLog.GetOrCreateGuildModerationLog(context.Guild.Id);
            UserModerationLog   userModerationLog  = guildModerationLog.GetOrCreateUserModerationLog(args.UserId);
            UserModerationEntry moderationEntry    = new UserModerationEntry(context.Guild.Id, ModerationType.Note, null, context.GuildUser, args.Note);
            await userModerationLog.AddModerationEntry(moderationEntry);

            await context.Channel.SendEmbedAsync($"Added Note `{args.Note}` to modlogs for {(args.TargetUser == null ? Markdown.InlineCodeBlock(args.UserId.ToString()) : args.TargetUser.Mention)}");
        }
예제 #24
0
        public override IElement Action(ArgumentContainer Args)
        {
            var args = Args.GetVisitedRestArguments();

            InnerScope.NewDynamicScope();
            InnerScope.AddNamesToDynamicScope(OnEnterBlock(args.Value));
            var bodyResult = Interpreter.VisitAndGetResult(Body);

            InnerScope.PopDynamicScope();
            return(bodyResult);
        }
예제 #25
0
        public void Builder_BuildString_Concat()
        {
            var container = new ArgumentContainer();

            container.Add(new ConcatArgument(concatFiles));
            container.Add(new OutputArgument("output.mp4"));

            var str = builder.BuildArguments(container);

            Assert.AreEqual(str, "-i \"concat:1.mp4|2.mp4|3.mp4|4.mp4\" \"output.mp4\"");
        }
예제 #26
0
 bool IsMessageYoungEnough(IMessage message, ArgumentContainer args)
 {
     if (args.End == EndMode.Time || args.End == EndMode.TimeRelative)
     {
         return(message.CreatedAt > args.DeleteAfter);
     }
     else
     {
         return(args.RemoveCount > 0);
     }
 }
예제 #27
0
 private void ButInsertAfter_Click(System.Object sender, System.EventArgs e)
 {
     if (IsFormComplete)
     {
         ArgumentContainer.Insert(ArgumentContainer.IndexOf(SelectedArgument.Value) + 1, new CustomAttributeNamedArgument(ItemName.Text, AttributeArgumentEditor.SelectedArgument));
         DialogResult = DialogResult.OK;
     }
     else
     {
         DialogResult = DialogResult.None;
     }
 }
예제 #28
0
        private XDocument CreateIdentify(DateTime date, ArgumentContainer arguments)
        {
            OaiVerb verb = OaiVerb.Identify;

            OaiArgument allowedArguments = OaiArgument.None;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            TryAddXElement(content, "repositoryName", _configuration.RepositoryName);
            TryAddXElement(content, "baseURL", _configuration.BaseUrl());
            TryAddXElement(content, "protocolVersion", _configuration.ProtocolVersion);

            if (_configuration.AdminEmails != null)
            {
                foreach (var adminEmail in _configuration.AdminEmails)
                {
                    TryAddXElement(content, "adminEmail", adminEmail);
                }
            }

            TryAddXElement(content, "earliestDatestamp", _configuration.EarliestDatestamp);
            TryAddXElement(content, "deletedRecord", _configuration.DeletedRecord);
            TryAddXElement(content, "granularity", GetDisplayGranularity());

            if (_configuration.Compressions != null)
            {
                foreach (var compression in _configuration.Compressions)
                {
                    TryAddXElement(content, "compression", compression);
                }
            }

            if (_configuration.Descriptions != null)
            {
                foreach (var description in _configuration.Descriptions)
                {
                    TryAddXElement(content, "description", description);
                }
            }

            return(CreateXml(date, root.ToArray()));
        }
 private void ButAppend_Click(object sender, EventArgs e)
 {
     if (IsFormComplete)
     {
         ArgumentContainer.Add(new CustomAttributeNamedArgument(ItemName.Text, AttributeArgumentEditor.SelectedArgument));
         DialogResult = DialogResult.OK;
     }
     else
     {
         DialogResult = DialogResult.None;
     }
 }
예제 #30
0
        public VideoInfo Convert(ArgumentContainer arguments)
        {
            var args   = ArgumentBuilder.BuildArguments(arguments);
            var output = ((OutputArgument)arguments[typeof(OutputArgument)]).GetAsFileInfo();

            if (!RunProcess(arguments, output))
            {
                throw new FFMpegException(FFMpegExceptionType.Operation, "Could not replace the video audio.");
            }

            return(new VideoInfo(output));
        }